分支限界法：最优装载问题

分支限界法的基本思想：
1)队列式（FIFO）式分支限界法
队列式分支限界法将活节点组织成一个队列，并按照队列“先进先出”的原则，选取下一个节点为当前拓展节点
2）优先队列式分支限界法
优先队列的分支限界法将活动表组织成一个优先队列，并按照队列规定的节点优先级选取最高的下一个节点成为当前拓展节点

eg：基于FIFO式分支限界法的最优装载问题
基本代码思路：
1：和回溯法的思路一样，用FIFO分支搜索所有的分支，并记录以搜索分支的最优解，搜索完子树也就找出了问题的最优解（遍历更新bestW过程）
2：要求出最优解，必须搜索到叶节点，当层数为n+1是，代表搜索完所有的节点，搜索结束
3：每层用’-1’来标志，否则入队无法识别自己所在的层，，并用变量i记录当前的层
4：更新当前的bestW

public class BranchLimitFIFOSearch {  
    private int 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队列
    private float [] r;//r[i]表示w[i]货物之后剩余的货物总重量

    public static void main(String[] args) {  
        int n = 3;  
        float c1 = 50;  
        float c2 = 50;  
        float[] w = { 0, 10, 40, 40 };  
        float[] r={0,0,0,0};
        BranchLimitFIFOSearch bfis = new BranchLimitFIFOSearch(n, c1, c2, w,r);  

        float s = bfis.getS();  
        if (s <= c1 || s <= c2) {  
            System.out.println("need only one ship!");  
        }  
        if (s > c1 + c2) {  
            System.out.println("no solution!，because s>c1+c2");  
            return;  
        }  
        bfis.maxLoading(c1);  
         float bestw = bfis.getBestw();  

        if (s - bestw <= c2) {  
            System.out.println("The first ship loading " + bestw);  
            System.out.println("The second ship loading " + (s - bestw));  
        } else {  
            System.out.println("no solution!,because s-bestw<=c2");  
        }  

    }  

    public BranchLimitFIFOSearch(int _n, float _c1, float _c2, float[] _w,float[] _r) {  
        n = _n;  
        c1 = _c1;  
        c2 = _c2;  
        w = _w;  
        r=_r;

        for (float f : _w) {  
            s += f;  
        }  
    }  

    public float maxLoading(float c) {
        r[w.length-1]=0;
        for(int i=w.length-2;i>=0;i--){
            r[i]=r[i+1]+w[i+1];
        }

        mq.put(new Float(-1)); // 初始化结点队列，标记分层  ,当元素的值为-1时候，表示已经达到空间书的同一层节点尾部
        int i = 1; // 结点的层  
        ew = 0; // 当前船的装载量  
        bestw = 0; // 目前的最优值  

        while (!mq.empty()) { // 搜索子集空间树  
            if (ew + w[i] <= c) { // 检查E-结点的左孩子，货箱i是否可以装载  
                addLiveNode(ew + w[i], i); // 货箱i可以装载  
            }  

            if((ew+r[i])>bestw){
            addLiveNode(ew, i); // 右孩子总是可行的，不装载货物i  ，当前路径无法取代bestW
     }


            ew = (Float) mq.get(); // 取下一个结点  

            if (ew == -1) { // 到达层的尾部  
                if (mq.empty()) {  
                    return bestw;  
                }  
                mq.put(new Float(-1));  
                ew = (Float) mq.get(); // 取下一个结点  
                i++; // ew的层  
            }  
        }  
        return bestw;  
    }  


    public void addLiveNode(float wt, int i) {//将当前载重两添加入队列  
        if (i == n) { // 是叶子  
            if (wt > bestw) {  
                bestw = wt;  
            }  
        } 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;  
    }  

}  

import java.util.LinkedList;

public class MyQueue {  
    private LinkedList ll = new LinkedList();  

    public void put(Object o) {  
        ll.addLast(o);  
    }  

    public Object get() {  
        return ll.removeFirst();  
    }  
    public boolean empty() {  
        return ll.isEmpty();  
    }  
}