分支界限法类似回溯法，也是在问题的解空间上搜索问题解的算法，其求解目标是找出满足约束条件的一个解(回溯是找出所有的解)或是在满足条件的解中找出最优解。 

搜索策略:在扩展结点处，先生成其所有的儿子节点(分支)，然后再从当前的活结点表中(根据每一活结点计算出的函数值)选择最有利的结点作为下一个扩展结点。

从活结点表中选择下一扩展结点的不同方式导致不同的分支界限法：

1、队列式(FIFO)分支界限法

2、优先队列式分支界限法

基本思想:以广度优先或以最小耗费(最大效益)优先的方式搜索问题的解空间树。

每个活结点都只有一次机会成为扩展结点，活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中，重复上述结点扩展过程，直至找出所需的解。

分支界限法是由"分支"策略和"限界"策略两部分组成。"分支"策略体现在对问题空间是按照广度优先策略进行搜索的；"限界"策略是为了加速搜索速度而采用启发信息剪枝的策略。

装载问题

 有两艘船和需要装运的n个货箱，第一艘船的载重量是c1，第二艘船的载重量是c2,wi是货箱的质量，且w1+w2+...+wn <= c1+c2. 

希望确定是否有一种可将所有n个货箱全部装船的方法。若有的话，找出该方法。

容易证明：如果一个给定装载问题有解，则采用下面的策略可得到最优装载方案。 

   (1)首先将第一艘轮船尽可能装满；

   (2)将剩余的集装箱装上第二艘轮船

该问题就转化为第一艘船的最大装载问题

import java.util.*;

/*FIFO分支搜索算法求解最优解*/
public class BranchLimitFIFOSearch {  
    public static void main(String[] args) {    
        int n = 3;     // n个货箱          
        float c1 = 50;  // 第一艘船的载重量         
        float c2 = 50;  // 第二艘船的载重量   
        float[] w = { 0, 10, 40, 40 };      // 货箱质量数组   
        // 测试例子  
        BranchLimitFIFOSearch bfis = new BranchLimitFIFOSearch(n, c1, c2, w);  
         
        float s = bfis.getS();  // s为所有货箱的重量之和 
        if (s <= c1 || s <= c2) {  
            System.out.println("只需要一艘船!");  
        }  
        if (s > c1 + c2) {  
            System.out.println("无解!");  
            return;  
        }  
        bfis.maxLoading(c1);  
        float bestw = bfis.getBestw();   
        if (s - bestw <= c2) { 
            System.out.println("第一艘船装载" + bestw);  
            System.out.println("第二艘船装载 " + (s - bestw));  
        } else {  
            System.out.println("无解!");  
        }   
    }   
    private int n; // n个货箱  
    private float c1; // 第一艘船的载重量  
    private float c2; // 第二艘船的载重量  
    private float bestw; // 第一艘船的最大装载量 
    private float ew = 0; // 当前船的装载量  
    private float[] w; // 货箱质量数组  
    private float s = 0; // 所有货箱的重量之和  
    private MyQueue mq = new MyQueue(); // FIFO队列  
    
    //构造方法      
    public BranchLimitFIFOSearch(int _n, float _c1, float _c2, float[] _w) {  
        n = _n;  
        c1 = _c1;  
        c2 = _c2;  
        w = _w;  
  
        for (float f : _w) {  
            s += f;  
        }  
    }   
  
    //最优装载值   
    public float maxLoading(float c) {  
        mq.put(new Float(-1)); // 初始化结点队列，"-1"入队标记分层  
        int i = 1; // E-结点的层  
        ew = 0; // 当前船的装载量  
        bestw = 0; // 目前的最优值  
  
        while (!mq.empty()) { // 搜索子集空间树  
            if (ew + w[i] <= c) { // 检查E-结点的左孩子，货箱i是否可以装载  
                addLiveNode(ew + w[i], i); // 货箱i可以装载  
            }   
            addLiveNode(ew, i); // 右孩子总是可行的(不需要检查)，不装载货物i    
            ew = (Float) mq.get(); // 取下一个结点  
  
            if (ew == -1) { // 到达层的尾部  
                if (mq.empty()) {  
                    return bestw;  
                } 
                mq.put(new Float(-1));//每处理完一层让"-1"入队，以此来标识"层"  
                ew = (Float) mq.get(); // 取下一个结点  
                i++; // ew的层 （当层次为n+1时，搜索完全部叶结点，算法结束） 
            }  
        }  
        return bestw;  
    }  
  
    //添加活结点(wt:当前装载量，i:当前层数)
    public void addLiveNode(float wt, int i) {  
        if (i == n) { // 可行叶结点 
            if (wt > bestw) {  
                bestw = wt;  //当前解由于当前最优解，更新bestw
            }  
        } else { // 非叶结点  
            mq.put(new Float(wt));  
        }  
    }  
  
    public int getN() {  
        return n;  
    }  
  
    public void setN(int n) {  
        this.n = n;  
    }  
  
    public float getC1() {  
        return c1;  
    }  
  
    public void setC1(float c1) {  
        this.c1 = c1;  
    }  
  
    public float getC2() {  
        return c2;  
    }  
  
    public void setC2(float c2) {  
        this.c2 = c2;  
    }  
  
    public float getBestw() {  
        return bestw;  
    }  
  
    public void setBestw(float bestw) {  
        this.bestw = bestw;  
    }  
  
    public float getEw() {  
        return ew;  
    }  
  
    public void setEw(float ew) {  
        this.ew = ew;  
    }  
  
    public float getS() {  
        return s;  
    }  
  
    public void setS(float s) {  
        this.s = s;  
    }  
  
//自定义队列
public class MyQueue {  
    private LinkedList list = new LinkedList();  
  
   //入队   
    public void put(Object o) {  
        list.addLast(o);  //链表末尾增加新元素
    }  
      
   // 出队     
    public Object get() {  
        return list.removeFirst();  
    }  
    
     //队是否为空     
    public boolean empty() {  
        return list.isEmpty();  
    }  
}  
}

本文出自 “闲庭信步、” 博客，请务必保留此出处http://macxiao.blog.51cto.com/9606147/1588900

分支界限法(BFS)