分支限界法基础练习笔记

 

　　分支限界法的本质也是穷举。同样地，把一个多阶段决策问题的每个决策和状态组织成一棵解空间树，然后遍历解空间树得到最优值和最优解。分支限界法的搜索方式是先搜索完一层的节点再搜索下一层。比如下面这棵子集树，搜索顺序是A→B→C→D→E→F→G→……→O.

  同一层的结点之间并没有什么联系，要按广度优先的顺序搜索结点，就要设一个队列使结点按顺序排列。因为广度优先搜索时每搜索一个活结点都会一次性产生其所有子节点，所以队列只需要记录活结点。又因为父结点和子结点之间可能包含其他活结点，所以每次产生子节点都从队尾入队。

　综上可得分支限界法的搜索方式：首先设队列Q; 活结点A入队，Q=[A]; 循环(第一次){ 取出队头元素A，扩张得到子节点B,C按顺序入队。} Q=[B,C]; 循环(第二次){ 取出队头元素B，扩张得到子节点D,E按顺序入队。} Q=[C,D,E];  循环(第三次){ 取出队头元素C，扩张得到子节点F,G按顺序入队。} Q=[D,E,F,G];  循环(第四次){ 取出队头元素D，扩张得到叶子节点H,I，叶子节点不必入队，直接比较最优值。} Q=[E,F,G]; 循环到Q=[]结束。搜索过程中同样可以用约束函数和限界函数剪枝。　　

  上述方法还有缺陷，既不能判断当前结点在第几层，也不能判断当前结点的父结点是哪个，所以无法判断叶子结点，也无法根据最优值结点构造最优解。可以设一个结点类，包含结点的父结点，决策，状态，以及所在层数。根节点层数为0，每个子节点的层数都是父结点的层数+1， 当层数为n时就能判断当前结点为叶子结点了。找到最优值结点时可以根据结点对象的决策和层数得到最优解的一个分量，追溯父结点直到根节点就能构造出最优解。以上就是队列式分支限界法。

  队列式分支限界法寻找最优值和最优解比回溯法还麻烦，搜索量没有变，还要花费存储空间。根据动态规划中以空间换时间的经验，队列式分支限界法显然还能优化一下。队列的作用是安排搜索顺序，可以尝试在排序上下功夫，而且结点对象包含了结点的所有信息，无论怎么排序都不影响其他操作。

  限界函数是用来判断一个结点的潜力的，对于最大化问题，当一个结点的上界函数值不大于当前最优值，则可以判断该节点的子结点树中不存在最优值，对该结点的子树剪枝。换个思路，当一个结点的上界函数值比其他已知的结点的上界函数值大时，这个结点的子树中存在最优值的可能性也更大，应该优先搜索该结点。所以可以给结点类增加一个变量：优先级，优先级的值等于该结点的上界函数值，使用优先队列按优先级对活结点实时排序，这样每次取出的头结点都是最有可能获得最优值的，以便尽快地找出一个最优值结点。因为优先级大于等于状态值，当一个叶子结点的状态值大于或等于当前队列头结点的优先级时，说明队列中的活结点都无法获得更优的子节点了，所以剩下的活结点也不必搜索了，这个叶子结点就是一个最优值结点。

 

【例1】装载问题：有一批共 n 个集装箱要装上 2 艘载重量分别为 c1 和 c2 的轮船，其中集装箱 i 的重量为 wi，且所有货物总重量<=c1+c2。要求确定是否有一个合理的装载方案可将这个集装箱装上这 2 艘轮船。如果有，找出一种装载方案。

首先将第一艘轮船尽可能装满，然后将剩余的集装箱装在第二艘轮船上。只需要找到尽可能把第一个轮船装满的方案就可获得最优值和最优解，相当于只考虑重量的0-1背包问题。为了简化设n=3。设1表示当前集装箱装入1船，0表示不装。解空间：{(1, 1, 1), (1, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 0), (0, 1, 1), (0, 0, 1), (0, 0, 0)}。解空间结构为子集树。

队列式分支限界法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Random;

public class Demo5 {
    public static void main(String[] args) {
        //集装箱数量
        int n = 20;
        //第一艘船的载重量
        int c1 = 30;
        //第二艘船的载重量
        int c2 = 30;
        //各个集装箱的重量
        int[] w = new int[n+1];
        //所有集装箱总重量
        int tW = 0;
        Random r = new Random();
        int num = 1;
        while (num<=n){
            int wi = r.nextInt((c1+c2)*2/n)+1;
            if ((tW+wi+(n-num)) <= (c1+c2)){
                w[num] = wi;
                tW+=wi;
                num++;
            }
        }
        System.out.println("第一艘船载重量是："+c1+" ; "+"第二艘船载重量是："+c2+" ;");
        System.out.println("各个集装箱的重量为：");
        int[] w1 = Arrays.copyOfRange(w,1,n+1);
        System.out.println(Arrays.toString(w1));
        //分支界限法开始时间
        long s = System.nanoTime();
        //分支界限法遍历解空间树
        Node optimalN = branchAndBound(n,c1,w);
        //分支界限法结束时间
        long e = System.nanoTime();
        //最终装入第一艘船的集装箱重量(最优值)
        int optimalV1 = optimalN.nodeW;
        //最终装入第二艘船的集装箱重量
        int optimalV2 = tW - optimalV1;
        //最终装入第一艘船的集装箱的代号(最优解集)
        ArrayList<Integer> optimalS1 = new ArrayList<>();
        //最终装入第二艘船的集装箱的代号
        ArrayList<Integer> optimalS2 = new ArrayList<>();
        for (int i = n; i > 0; i--) {
            if (optimalN.layer == i) {
                if (optimalN.isLeft) {
                    optimalS1.add(i);
                } else {
                    optimalS2.add(i);
                }
                optimalN = optimalN.parent;
            }else {
                optimalS2.add(i);
            }
        }
        Collections.sort(optimalS1);
        Collections.sort(optimalS2);
        System.out.println("装入第一艘船的集装箱重量是：" + optimalV1);
        System.out.println("装入第一艘船的集装箱编号是：" + optimalS1);
        System.out.println("装入第二艘船的集装箱重量是：" + optimalV2);
        System.out.println("装入第二艘船的集装箱编号是：" + optimalS2);
        System.out.println("遍历解空间树用时："+(e - s)+"纳秒");
    }
    //结点类
    public static class Node {
        //本结点的父结点
        Node parent;
//本结点的载重量(第一艘船当前载重量)
        int nodeW;
//层数对应集装箱编号
        int layer;        
//判断是否是左子结点，(记录决策)
boolean isLeft;        
public Node(Node parent, int nodeW, int layer, boolean isLeft) {
            this.parent = parent;
            this.nodeW = nodeW;
            this.layer = layer;
            this.isLeft = isLeft;
        }

        public Node() {
        }
    }
    private static Node branchAndBound(int n, int c1, int[] w) {/* i记录层数，每层表示对第i个集装箱的选择(已确定的，第一结点还没选记为0)*/
        //记录活结点的队列
        LinkedList<Node> activeNode = new LinkedList<>();
        //第一个活结点入队
        activeNode.offer(new Node(null,0,0,false));
        //记录最优值节点
        Node optimalN = new Node();
        //每次循环搜索完一个结点的所有子结点。
        while (true){
            Node cNode = activeNode.poll();
            assert cNode != null;
            //获取当前遍历的结点的载重量
            int cW = cNode.nodeW;
            int cLayer = cNode.layer + 1;
            int leftW = cW + w[cLayer];
            int rW = 0;
            for (int i = cLayer+1; i <= n; i++) {
                rW += w[i];
            }
            //如果集装箱i能装入第一艘船就装船，创建一个新的左儿子结点
            if (leftW <= c1 ){
                Node leftSonNode = new Node(cNode,leftW,cLayer,true);
                //如果当前结点的载重量大于最优值的就更最优值结点
                if (leftW > optimalN.nodeW) {
                    optimalN = leftSonNode;
                }
                /*非叶子结点，主要是在创建子结点时帮助获取父结点数据，叶子结点没有子节点了就不需要放入活结点队列了。*/
                if (cLayer < n) {
                    //左儿子结点入队
                    activeNode.offer(leftSonNode);
                }
            }
            if (cLayer < n && cW + rW > optimalN.nodeW) {
                /*先计算右子树根节点的上界，如果其上界值>当前的最优值，右子树中就可能
                存在第一艘船的装载最优解，则创建一个新的右儿子结点。*/
                Node rightSonNode = new Node(cNode, cW,cLayer,false);
                //右儿子结点入队
                activeNode.offer(rightSonNode);
            }
            if (activeNode.isEmpty()){
                return optimalN;
            }
        }
    }
}

优先队列式分支限界法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Random;

public class Demo6 {
    public static void main(String[] args) {
        //集装箱数量
        int n = 10;
        //第一艘船的载重量
        int c1 = 30;
        //第二艘船的载重量
        int c2 = 30;
        //各个集装箱的重量
        int[] w = new int[n+1];
        //所有集装箱总重量
        int tW = 0;
        //最终装入第一艘船的集装箱重量(最优值)
        Random r = new Random();
        int num = 1;
        while (num<=n){
            int wi = r.nextInt((c1+c2)*2/n)+1;
            if ((tW+wi+(n-num)) <= (c1+c2)){
                w[num] = wi;
                tW+=wi;
                num++;
            }
        }
        System.out.println("第一艘船载重量是："+c1+" ; "+"第二艘船载重量是："+c2+" ;");
        System.out.println("各个集装箱的重量为：");
        int[] w1 = Arrays.copyOfRange(w,1,n+1);
        System.out.println(Arrays.toString(w1));
        //分支界限法开始时间
        long s = System.nanoTime();
        //分支界限法遍历解空间树
        Node optimalN = branchAndBound(n,c1,w,tW);
        //分支界限法结束时间
        long e = System.nanoTime();
        int optimalV1 = optimalN.nodeW;
        //最终装入第二艘船的集装箱重量
        int optimalV2 = tW - optimalV1;
        //最终装入第一艘船的集装箱的代号(最优解集)
        ArrayList<Integer> optimalS1 = new ArrayList<>();
        //最终装入第二艘船的集装箱的代号
        ArrayList<Integer> optimalS2 = new ArrayList<>();
        for (int i = n; i > 0; i--) {
            if (optimalN.layer == i) {
                if (optimalN.isLeft) {
                    optimalS1.add(i);
                } else {
                    optimalS2.add(i);
                }
                optimalN = optimalN.parent;
            }else {
                optimalS2.add(i);
            }
        }
        Collections.sort(optimalS1);
        Collections.sort(optimalS2);
        System.out.println("装入第一艘船的集装箱重量是：" + optimalV1);
        System.out.println("装入第一艘船的集装箱编号是：" + optimalS1);
        System.out.println("装入第二艘船的集装箱重量是：" + optimalV2);
        System.out.println("装入第二艘船的集装箱编号是：" + optimalS2);
        System.out.println("遍历解空间树用时："+(e - s)+"纳秒");
    }//结点类
    public static class Node{
        //本结点的父结点
        Node parent;
        //本结点的载重量(记录状态)
        int nodeW;
        //层数对应集装箱编号
        int layer;
        //当前结点的优先级(上界函数值)
        int priority;
        //是否是左儿子结点，(记录决策)
        boolean isLeft;

        public Node(Node parent, int nodeW, int layer, int priority, boolean isLeft) {
            this.parent = parent;
            this.nodeW = nodeW;
            this.layer = layer;
            this.priority = priority;
            this.isLeft = isLeft;
        }
    }

    public static Node branchAndBound (int n, int c1, int[] w, int tW) { /* i记录层数，每层表示对第i个集装箱的选择(已确定的，第一结点还没选记为0),
    j记录活结点的个数减一，为了获取活结点队列的最后一个元素，方便标记每一层的最后一个结点。*/
        //记录活结点的队列
        PriorityQueue<Node> activeNode = new PriorityQueue<>((node1, node2) -> node2.priority - node1.priority);
        //根结点入队
        activeNode.offer(new Node(null,0,0,tW,false));
        //每次循环搜索完一个结点的所有子结点。
        while (true){
            //取出队头活结点
            Node cNode = activeNode.poll();
            assert cNode != null;
            //获取当前活结点的载重量
            int cW = cNode.nodeW;
            //子结点层数=父结点层数+1
            int cLayer = cNode.layer + 1;
            //左子结点的重量
            int leftW = cW + w[cLayer];
            //剩余集装箱总重量
            int rW = cNode.priority-leftW;
            //如果当前集装箱cLayer能装入第一艘船就装船，创建一个新的左儿子结点
            if (leftW <= c1 ){
                Node leftN = new Node(cNode,leftW,cLayer,leftW+rW,true);
                if (cLayer<n){
                    //非叶子节点入队
                    activeNode.offer(leftN);
//右子节点的状态等于父节点，优先级小于父节点，所以不必参与最优值判断
activeNode.offer(new Node(cNode,cW,cLayer,cW+rW,false));
                }else {//如果是叶子节点则对比当前活节点队列的最大优先级
                    assert activeNode.peek() != null;
                    if (leftW>=activeNode.peek().priority){
                        //返回最优值节点
                        return leftN;
                    }
                }
            }
        }
    }
}

【例2】0-1背包：物品20件，背包容量50，物品重量1-20随机赋值，物品价值1-50随机赋值。

为了简化设n=3。设1表示当前物品装入背包，0表示不装。解空间：{(1, 1, 1), (1, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 0), (0, 1, 1), (0, 0, 1), (0, 0, 0)}。解空间结构为子集树。

解空间树：

 

 优先队列式分支限界法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Random;

public class Demo12 {
    public static void main(String[] args) {
        //物品数量
        int n = 10;
        //背包容量
        int c = 50;
        //各个物品重量和价值。忽略下标0元素，goods[i][0]表示物品i的重量，goods[i][1]表示物品i的价值
        int[][] goods = new int[n+1][2];
        //所有物品的总价值
        int tV = 0;
        Random r = new Random();
        //随机赋值
        for (int i = 1; i <= n; i++) {
            goods[i][0] = r.nextInt(20)+1;
            goods[i][1] = r.nextInt(50)+1;
            tV += goods[i][1];
        }
        System.out.println("背包容量为：" + c);
        System.out.println("所有物品的重量和价值为：" );
  for (int i = 1; i <= n; i++) {
            if (i%5 == 0){
                System.out.println(Arrays.toString(goods[i]));
            }else {
                System.out.print(Arrays.toString(goods[i])+" ");
            }
        }
        long s = System.nanoTime();
        Node optimalN = branchAndBound(n,c,goods,tV);
        long e = System.nanoTime();
        //(最优值)
        int optimalV = optimalN.nodeV;
        //(最优解)
        ArrayList<Integer> optimalS = new ArrayList<>();
        for (int i = n; i > 0; i--) {
            if (optimalN.layer == i) {
                if (optimalN.isLeft) {
                    optimalS.add(i);
                }
                optimalN = optimalN.parent;
            }
        }
        Collections.sort(optimalS);
        System.out.println("放入背包的物品价值为："+optimalV);
        System.out.println("放入背包的物品编号为：" +optimalS);
        System.out.println("算法用时"+(e-s)+"纳秒");
    }
    public static class Node{
        //父母结点
        Node parent;
        //当前结点的重量
        int nodeW;
        //当前结点的价值
        int nodeV;
        //当前结点的层数,对应物品编号
        int layer;
        //当前结点的优先级，(上界函数值)
        int priority;
        //是否是左儿子结点，(记录决策)
        boolean isLeft;

        public Node(Node parent, int nodeW, int nodeV, int layer, int priority, boolean isLeft) {
            this.parent = parent;
            this.nodeW = nodeW;
            this.nodeV = nodeV;
            this.layer = layer;
            this.priority = priority;
            this.isLeft = isLeft;
        }
    }

    private static Node branchAndBound (int n, int c, int[][] goods,int tV) {
        //活结点队列
        PriorityQueue<Node> activeNode = new PriorityQueue<>((node1, node2) -> node2.priority - node1.priority);
        //根节点入队
        activeNode.offer(new Node(null,0,0,0,tV,false));
        //每次循环搜索完一个结点的所有子结点。
        while (true){
            //取出队头活结点
            Node cNode = activeNode.poll();
            assert cNode != null;
            //获取当前活结点的重量和价值
            int cW = cNode.nodeW;
            int cV = cNode.nodeV;
            //子结点层数=父结点层数+1
            int cLayer = cNode.layer + 1;
            //左子节点的重量和价值
            int leftW = cW + goods[cLayer][0];
            int leftV = cV + goods[cLayer][1];
            //剩余物品总价值
            int rV = cNode.priority-leftV;
            //如果当前物品cLayer能装入背包就装，创建一个新的左子节点
            if (leftW <= c){
                Node leftN = new Node(cNode,leftW,leftV,cLayer,leftV+rV,true);
                if (cLayer < n) {
                    //非叶子节点入队
                    activeNode.offer(leftN);
                    //右子节点的状态等于父节点，优先级小于父节点，所以不必参与最优值判断
                    activeNode.offer(new Node(cNode,cW,cV,cLayer,cV+rV,false));
                }else {//如果是叶子节点则对比当前活节点队列的最大优先级
                    assert activeNode.peek() != null;
                    if (leftV>=activeNode.peek().priority){
                        //返回最优值节点
                        return leftN;
                    }
                }
            }
        }
    }
}

【例3】旅行售货员问题：某售货员要到若干城市去推销商品，一直各城市之间的路程，他要选定一条从驻地出发，经过每个城市一遍，最后回到住地的路线，使总的路程最短。

解空间：{(1,2,3,4),(1,2,4,3),(1,3,2,4),(1,3,4,2),(1,4,2,3),(1,4,3,2)}。解空间结构为排列树。

解空间树：

搜索到叶子节点加上返回1的路程才是最终状态值。

优先队列式分支限界法(优先级为当出发点到当前节点的距离)：

 

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

public class Demo7 {
    public static void main(String[] args) {
        //城市数量
        int n = 4;
        //出发城市
        int starCity = 1;
        //邻接矩阵
        int[][] map = {{0, 0, 0, 0, 0},
                         {0, 0,30, 6, 4},
                         {0,30, 0, 5,10},
                         {0, 6, 5, 0,20},
                         {0, 4,10,20, 0}};

        Node optimalN = branchAndBound(n,starCity,map);
        System.out.println("最优值为："+optimalN.dist);
        int[] optimalR = new int[n+1];
        optimalR[0] = starCity;
        optimalR[n] = starCity;
        System.out.print("最优解为：");
        for (int i = n-1; i > 0; i--) {
            optimalR[i] = optimalN.city;
            optimalN = optimalN.parent;
        }
        System.out.println(Arrays.toString(optimalR));
    }
    public static class Node {
        //父母节点
        Node parent;
        //当前节点的累计距离(状态),也当作优先级。
        int dist;
        //层数代表第几个城市(阶段)
        int layer;
        //当前所在城市编号(决策)
        int city;
        //走过的城市
        boolean[] pass;

        public Node(Node parent, int dist, int layer, int city, boolean[] pass) {
            this.parent = parent;
            this.dist = dist;
            this.layer = layer;
            this.city = city;
            this.pass = pass;
        }

        public Node() {
        }
    }
    private static Node branchAndBound(int n, int starCity, int[][] map){
        //活结点队列
        PriorityQueue<Node> activeNode = new PriorityQueue<>(Comparator.comparingInt(node -> node.dist));
        //根节点入队
        boolean[] pass = new boolean[n+1];
        pass[starCity] = true;
        activeNode.offer(new Node(null,0,1,starCity,pass));
        //记录最优值结点，初始距离为无穷大，方便后面比较。
        Node optimalN = new Node();
        optimalN.dist=Integer.MAX_VALUE;
        while (true){
            //取出队头活节点
            Node cNode = activeNode.poll();
            assert cNode != null;
            //遍历地图数据
            for (int i = 1; i <= n; i++) {
                //如果当前节点所在城市能直达i城并且当前节点的路径没走过i城，就对i城创建一个子节点
                if (map[cNode.city][i]!= 0 && !cNode.pass[i] ){
                    //依据父节点更新子节点数据
                    int dist = cNode.dist+map[cNode.city][i];
                    int layer = cNode.layer+1;
                    boolean[] pass1 = Arrays.copyOf(cNode.pass,cNode.pass.length);
                    pass1[i] = true;
                    //创建子节点对象
                    Node sNode = new Node(cNode,dist,layer,i,pass1);
                    if (sNode.layer < n){
                        //非叶子节点入队
                        activeNode.offer(sNode);
                    }else {//先更新最优值节点
                        dist+=map[i][starCity];
                        if (dist < optimalN.dist){
                            sNode.dist=dist;
                            optimalN = sNode;
                        }//如果最优值节点的优先级不大于活节点队列头节点的优先级就找到一个最优值节点
                        assert activeNode.peek() != null;
                        if (optimalN.dist <= activeNode.peek().dist){
                            return optimalN;
                        }
                    }
                }
            }
        }
    } 
/*打印结果：
   最优值为：25
   最优解为：[1, 3, 2, 4, 1]*/
}