Outline

  • 前言
  • Example-1
  • Example-2
  • 运行说明

00 前言

前面一篇文章我们讲了branch and bound算法的相关概念。可能大家对精确算法实现的印象大概只有一个,调用求解器进行求解,当然这只是一部分。其实精确算法也好,启发式算法也好,都是独立的算法,可以不依赖求解器进行代码实现的,只要过程符合算法框架即可。

只不过平常看到的大部分是精确算法在各种整数规划模型上的应用,为此难免脱离不了cplex等求解器。这里简单提一下。今天给大家带来的依然是branch and bound算法在整数规划中的应用的代码实现,所以还是会用到部分求解器的。

注:本文代码下载请关注公众号【程序猿声】,后台回复【bbcode】,不包括【】即可下载!

01 Example-1

首先来看第一个代码实例,该代码求解的是整数优化的模型,关于branch and bound求解整数规划的具体原理就不再概述了,和上一篇文章差不多但是有所区别。代码文件层次如下:

其中branch and bound算法主要部分在BnB_Guide.java这个文件。ExampleProblem.java内置了三个整数规划模型的实例。调用的是scpsolver这个求解器的wrapper,实际调用的还是lpsolver这个求解器用以求解线性松弛模型。下面着重讲讲BnB_Guide.java这个文件。

  1. public BnB_Guide(int demoProblem){
  2. example = new ExampleProblem(demoProblem);
  3. LinearProgram lp = new LinearProgram();
  4. lp = example.getProblem().getLP();
  5. solver = SolverFactory.newDefault();
  6. double[] solution = solver.solve(lp); // Solution of the initial relaxation problem
  7. int maxElement = getMax(solution); // Index of the maximum non-integer decision variable's value
  8. if(maxElement == -1 ) // We only got integers as values, hence we have an optimal solution
  9. verifyOptimalSolution(solution,lp);
  10. else
  11. this.solveChildProblems(lp, solution, maxElement); // create 2 child problems and solve them
  12. printSolution();
  13. }

该过程是算法主调用过程:

  1. 首先变量lp保存了整数规划的松弛问题。
  2. 在调用求解器求解松弛模型以后,判断是否所有决策变量都是整数了,如果是,已经找到最优解。
  3. 如果不是,根据找出最大的非整数的决策变量,对该变量进行分支,solveChildProblems。

接着是分支子问题的求解过程solveChildProblems如下:

  1. public void solveChildProblems(LinearProgram lp, double[] solution ,int maxElement){
  2. searchDepth++;
  3. LinearProgram lp1 = new LinearProgram(lp);
  4. LinearProgram lp2 = new LinearProgram(lp);
  5. String constr_name = "c" + (lp.getConstraints().size() + 1); // Name of the new constraint
  6. double[] constr_val = new double[lp.getDimension()]; // The variables' values of the new constraint
  7. for(int i=0;i<constr_val.length;i++){ // Populate the table
  8. if(i == maxElement )
  9. constr_val[i] = 1.0;
  10. else
  11. constr_val[i] = 0;
  12. }
  13. //Create 2 child problems: 1. x >= ceil(value), 2. x <= floor(value)
  14. lp1.addConstraint(new LinearBiggerThanEqualsConstraint(constr_val, Math.ceil(solution[maxElement]), constr_name));
  15. lp2.addConstraint(new LinearSmallerThanEqualsConstraint(constr_val, Math.floor(solution[maxElement]), constr_name));
  16. solveProblem(lp1);
  17. solveProblem(lp2);
  18. }

具体的分支过程如下:

  1. 首先新建两个线性的子问题。
  2. 两个子问题分别添加需要分支的决策变量新约束:1. x >= ceil(value), 2. x <= floor(value)。
  3. 一切准备就绪以后,调用solveProblem求解两个子问题。

而solveProblem的实现代码如下:

  1. private void solveProblem(LinearProgram lp) {
  2. double[] sol = solver.solve(lp);
  3. LPSolution lpsol = new LPSolution(sol, lp);
  4. double objVal = lpsol.getObjectiveValue();
  5. if(lp.isMinProblem()) {
  6. if(objVal > MinimizeProblemOptimalSolution) {
  7. System.out.println("cut >>> objVal = "+ objVal);
  8. return;
  9. }
  10. }
  11. else {
  12. if(objVal < MaximizeProblemOptimalSolution) {
  13. System.out.println("cut >>> objVal = "+ objVal);
  14. return;
  15. }
  16. }
  17. System.out.println("non cut >>> objVal = "+ objVal);
  18. int maxElement = this.getMax(sol);
  19. if(maxElement == -1 && lp.isFeasable(sol)){ //We found a solution
  20. solutionFound = true;
  21. verifyOptimalSolution(sol,lp);
  22. }
  23. else if(lp.isFeasable(sol) && !solutionFound) //Search for a solution in the child problems
  24. this.solveChildProblems(lp, sol, maxElement);
  25. }

该过程如下:

  1. 首先调用求解器求解传入的线性模型。
  2. 然后实行定界剪支,如果子问题的objVal比当前最优解还要差,则剪掉。
  3. 如果不剪,则判断是否所有决策变量都是整数以及解是否可行,如果是,找到新的解,更新当前最优解。
  4. 如果不是,根据找出最大的非整数的决策变量,对该变量再次进行分支,进入solveChildProblems。

从上面的逻辑过程可以看出,solveChildProblems和solveProblem两个之间相互调用,其实这是一种递归。该实现方式进行的就是BFS广度优先搜索的方式遍历搜索树。

02 Example-2

再来看看第二个实例:

input是模型的输入,输入的是一个整数规划的模型。由于输入和建模过程有点繁琐,这里就不多讲了。挑一些重点讲讲具体是分支定界算法是怎么运行的就行。

首先该代码用了stack的作为数据结构,遍历搜索树的方式是DFS即深度优先搜索,我们来看BNBSearch.java这个文件:

  1. public class BNBSearch {
  2. Deque<searchNode> searchStack = new ArrayDeque<searchNode>();
  3. double bestVal = Double.MAX_VALUE;
  4. searchNode currentBest = new searchNode();
  5. IPInstance solveRel = new IPInstance();
  6. Deque<searchNode> visited = new ArrayDeque<searchNode>();
  7. public BNBSearch(IPInstance solveRel) {
  8. this.solveRel = solveRel;
  9. searchNode rootNode = new searchNode();
  10. this.searchStack.push(rootNode);
  11. };

BNBSearch 这个类是branch and bound算法的主要过程,成员变量如下:

  • searchStack :构造和遍历生成树用的,栈结构。
  • bestVal:记录当前最优解的值,由于求的最小化问题,一开始设置为正无穷。
  • currentBest :记录当前最优解。
  • solveRel :整数规划模型。
  • visited :记录此前走过的分支,避免重复。

然后在这里展开讲一下searchNode就是构成搜索树的节点是怎么定义的:


  1. public class searchNode {
  2. HashMap<Integer, Integer> partialAssigned = new HashMap<Integer, Integer>();
  3. public searchNode() {
  4. super();
  5. }
  6. public searchNode(searchNode makeCopy) {
  7. for (int test: makeCopy.partialAssigned.keySet()) {
  8. this.partialAssigned.put(test, makeCopy.partialAssigned.get(test));
  9. }
  10. }
  11. }

其实非常简单,partialAssigned 保存的是部分解的结构,就是一个HashMap,key保存的是决策变量,而value对应的是决策变量分支的取值(0-1)。举上节课讲过的例子:

比如:

  • 节点1的partialAssigned == { {x3, 1} }。
  • 节点2的partialAssigned == { {x3, 0} }。
  • 节点3的partialAssigned == { {x3, 1}, {x2, 1} }。
  • 节点4的partialAssigned == { {x3, 1}, {x2, 0} }。
  • 节点7的partialAssigned == { {x3, 0}, {x1, 1}, {x2, 1}}。

    ……

想必各位已经明白得不能再明白了。

然后就可以开始BB过程了:

  1. public int solveIP() throws IloException {
  2. while (!this.searchStack.isEmpty()) {
  3. searchNode branchNode = this.searchStack.pop();
  4. boolean isVisited = false;
  5. for (searchNode tempNode: this.visited) {
  6. if (branchNode.partialAssigned.equals(tempNode.partialAssigned)){
  7. isVisited = true;
  8. break;
  9. }
  10. }
  11. if (!isVisited) {
  12. visited.add(new searchNode(branchNode));
  13. double bound = solveRel.solve(branchNode);
  14. if (bound > bestVal || bound == 0) {
  15. //System.out.println(searchStack.size());
  16. }
  17. if (bound < bestVal && bound!=0) {
  18. if (branchNode.partialAssigned.size() == solveRel.numTests) {
  19. //分支到达低端,找到一个满足整数约束的可行解,设置为当前最优解。
  20. //System.out.println("YAY");
  21. this.bestVal = bound;
  22. this.currentBest = branchNode;
  23. }
  24. }
  25. if (bound < bestVal && bound!=0) {
  26. //如果还没到达低端,找一个变量进行分支。
  27. if (branchNode.partialAssigned.size() != solveRel.numTests) {
  28. int varToSplit = getSplitVariable(branchNode);
  29. if (varToSplit != -1) {
  30. searchNode left = new searchNode(branchNode);
  31. searchNode right = new searchNode(branchNode);
  32. left.partialAssigned.put(varToSplit, 0);
  33. right.partialAssigned.put(varToSplit, 1);
  34. this.searchStack.push(left);
  35. this.searchStack.push(right);
  36. }
  37. }
  38. }
  39. }
  40. }
  41. return (int) bestVal;
  42. }

首先从搜索栈里面取出一个节点,判断节点代表的分支是否此前已经走过了,重复的工作就不要做了嘛。

如果没有走过,那么在该节点处进行定界操作,从该节点进入,根据partialAssigned 保存的部分解结构,添加约束,建立松弛模型,调用cplex求解。具体求解过程如下:

  1. public double solve(searchNode node) throws IloException {
  2. try {
  3. cplex = new IloCplex();
  4. cplex.setOut(null);
  5. IloNumVarType [] switcher = new IloNumVarType[2];
  6. switcher[0] = IloNumVarType.Int;
  7. switcher[1] = IloNumVarType.Float;
  8. int flag = 1;
  9. IloNumVar[] testUsed = cplex.numVarArray(numTests, 0, 1, switcher[flag]);
  10. IloNumExpr objectiveFunction = cplex.numExpr();
  11. objectiveFunction = cplex.scalProd(testUsed, costOfTest);
  12. cplex.addMinimize(objectiveFunction);
  13. for (int j = 0; j < numDiseases*numDiseases; j++) {
  14. if (j % numDiseases == j /numDiseases) {
  15. continue;
  16. }
  17. IloNumExpr diffConstraint = cplex.numExpr();
  18. for (int i = 0; i < numTests; i++) {
  19. if (A[i][j/numDiseases] == A[i][j%numDiseases]) {
  20. continue;
  21. }
  22. diffConstraint = cplex.sum(diffConstraint, testUsed[i]);
  23. }
  24. cplex.addGe(diffConstraint, 1);
  25. diffConstraint = cplex.numExpr();
  26. }
  27. for (int test: node.partialAssigned.keySet()) {
  28. cplex.addEq(testUsed[test], node.partialAssigned.get(test));
  29. }
  30. //System.out.println(cplex.getModel());
  31. if(cplex.solve()) {
  32. double objectiveValue = (cplex.getObjValue());
  33. for (int i = 0; i < numTests; i ++) {
  34. if (cplex.getValue(testUsed[i]) == 0) {
  35. node.partialAssigned.put(i, 0);
  36. }
  37. else if (cplex.getValue(testUsed[i]) == 1) {
  38. node.partialAssigned.put(i, 1);
  39. }
  40. }
  41. //System.out.println("LOL"+node.partialAssigned.size());
  42. return objectiveValue;
  43. }
  44. }
  45. catch(IloException e) {
  46. System.out.println("Error " + e);
  47. }
  48. return 0;
  49. }

中间一大堆建模过程就不多讲了,具体分支约束是这一句:

  1. for (int test: node.partialAssigned.keySet()) {
  2. cplex.addEq(testUsed[test], node.partialAssigned.get(test));
  3. }

此后,求解完毕后,把得到整数解的决策变量放进partialAssigned,不是整数后续操作。然后返回目标值。

然后依旧回到solveIP里面,在进行求解以后,得到目标值,接下来就是定界操作了:

  • if (bound > bestVal || bound == 0):剪支。
  • if (bound < bestVal && bound!=0):判断是否所有决策变量都为整数,如果是,找到一个可行解,更新当前最优解。如果不是,找一个小数的决策变量入栈,等待后续分支。

03 运行说明

Example-1:

运行说明,运行输入参数1到3中的数字表示各个不同的模型,需要在32位JDK环境下才能运行,不然会报nullPointer的错误,这是那份求解器wrapper的锅。怎么设置参数参考cplexTSP那篇,怎么设置JDK环境就不多说了。

然后需要把代码文件夹下的几个jar包给添加进去,再把lpsolve的dll给放到native library里面,具体做法还是参照cplexTSP那篇,重复的内容我就不多说了。

Example-2:

最后是运行说明:该实例运行调用了cplex求解器,所以需要配置cplex环境才能运行,具体怎么配置看之前的教程。JDK环境要求64位,无参数输入。

代码来源GitHub,经过部分修改。

干货 | 10分钟搞懂branch and bound(分支定界)算法的代码实现附带java代码的更多相关文章

  1. 10分钟搞懂Tensorflow 逻辑回归实现手写识别

    1. Tensorflow 逻辑回归实现手写识别 1.1. 逻辑回归原理 1.1.1. 逻辑回归 1.1.2. 损失函数 1.2. 实例:手写识别系统 1.1. 逻辑回归原理 1.1.1. 逻辑回归 ...

  2. 10分钟搞懂toString和valueOf函数(详细版)

    首先要说明的是这两种方法是toPrimitive抽象操作里会经常用到的. 默认情况下,执行这个抽象操作时会先执行valueOf方法,如果返回的不是原始值,会继续执行toString方法,如果返回的还不 ...

  3. 花10分钟搞懂开源框架吧 - 【NancyFx.Net】

    NancyFx是什么? Nancy是一个轻量级的独立的框架,下面是官网的一些介绍: Nancy 是一个轻量级用于构建基于 HTTP 的 Web 服务,基于 .NET 和 Mono 平台,框架的目标是保 ...

  4. 干货 | 10分钟带你全面掌握branch and bound(分支定界)算法-概念篇

    00 前言 之前一直做启发式算法,最近突然对精确算法感兴趣了.但是这玩意儿说实话是真的难,刚好boss又叫我学学column generation求解VRP相关的内容.一看里面有好多知识需要重新把握, ...

  5. 干货 | 10分钟掌握branch and cut(分支剪界)算法原理附带C++求解TSP问题代码

    00 前言 branch and cut其实还是和branch and bound脱离不了干系的.所以,在开始本节的学习之前,请大家还是要务必掌握branch and bound算法的原理. 01 应 ...

  6. 干货 | 10分钟教你用column generation求解vehicle routing problems

    OUTLINE 前言 VRPTW description column generation Illustration code reference 00 前言 此前向大家介绍了列生成算法的详细过程, ...

  7. c#代码 天气接口 一分钟搞懂你的博客为什么没人看 看完python这段爬虫代码,java流泪了c#沉默了 图片二进制转换与存入数据库相关 C#7.0--引用返回值和引用局部变量 JS直接调用C#后台方法(ajax调用) Linq To Json SqlServer 递归查询

    天气预报的程序.程序并不难. 看到这个需求第一个想法就是只要找到合适天气预报接口一切都是小意思,说干就干,立马跟学生沟通价格. ​ ​不过谈报价的过程中,差点没让我一口老血喷键盘上,话说我们程序猿的人 ...

  8. 【转】让你10分钟搞定Mac--最简单快速的虚拟安装

    文章出处:让你10分钟搞定Mac--最简单快速的虚拟安装http://bbs.itheima.com/thread-106643-1-1.html (出处: 黑马程序员训练营论坛) 首先说明一下. 第 ...

  9. [转帖]10分钟看懂Docker和K8S

    10分钟看懂Docker和K8S https://zhuanlan.zhihu.com/p/53260098 2010年,几个搞IT的年轻人,在美国旧金山成立了一家名叫“dotCloud”的公司. 这 ...

随机推荐

  1. The four Day 给出一个平衡字符串,将它分割成尽可能多的平衡字符串

    """ 在一个「平衡字符串」中,'L' 和 'R' 字符的数量是相同的. 给出一个平衡字符串 s,请你将它分割成尽可能多的平衡字符串. 返回可以通过分割得到的平衡字符串的 ...

  2. C#高效编程

    一. 使用readonly而不是const const是编译时常量,readonly是运行时常量.如果引用了一个库中的const常量,则在更新了程序集,但应用程序没有重新编译时,运行结果会出错 如程序 ...

  3. spring Boot 学习(二、Spring Boot与缓存)

    一.概述1. 大多应用中,可通过消息服务中间件来提升系统异步通信.扩展解耦能力 2. 消息服务中两个重要概念: 消息代理(message broker)和目的地(destination) 当消息发送者 ...

  4. C#类类型

    一.类和对象 假设我开了一家烤鱼店,每当客人来点餐时,我就会用笔和纸记录这笔订单,并计算出每单的价格.以下是记录的订单: 单号:00001种类:清江鱼口味:香辣配菜:豆腐价格:140元-------- ...

  5. python 4. path的定义及参数,re_path

    path定义 path函数的定义为:path(route,view,name=None,kwargs=None) 可以查看官方文档 → 官方文档,下面是取自官方文档关于path的参数 函数 path( ...

  6. 将windows共享文件夹挂载到Linux

    今天想用docker部署下 .net core的 服务,需要把代码文件从windows传到linux,以前一直都是拖拽的,这次安装的系统没有图形界面, 所以到网上找到了下面的这种方法,将共享文件夹挂载 ...

  7. honeyd路由拓扑

    create router //创建路由器模版 set router personality "Cisco 7206 running IOS 11.1(24)" //指纹 add ...

  8. python模块之json pickle

    1.json模块 功能:将其他形式的数据类型转化为json字符串类型,将json字符串转化为其他对应的数据类型 方法:json.dumps()  作用:将所有单引号变成双引号:将所有数据类型变成字符串 ...

  9. 高阶函数概念以及map/filter/reduce

    什么样的函数叫高阶函数:map(func, *iterables) --> map object 条件:1.函数接受函数作为参数 2.函数的返回值中包含函数 num_l = [1,2,3,4,5 ...

  10. QuickStart系列:Docker部署PostgreSQL

    docker镜像地址: https://hub.docker.com/_/postgres/ https://www.widuu.com/chinese_docker/examples/postgre ...