贪心算法-泊松分酒问题

讲这道题纯粹就是比较好玩,就记录一下.泊松分酒是很著名的一道题,讲的是假设某人有12品脱的啤酒一瓶，想从中倒出六品脱，但是恰巧身边没有6品脱的容器，仅有一个8品脱和一个5品脱的容器，怎样倒才能将啤酒分为两个6品脱呢？

代码：

import java.util.LinkedList;
import java.util.Set;
public class Oil {
    static class Status{
         static int[] full={12,8,5};//满的状态
         int[] bottle=new int[3];//瓶子的状态
         Status from;//从哪个状态来的

         public Status(int a,int b,int c){
             bottle[0]=a;
             bottle[1]=b;
             bottle[2]=c;
         }

         //获取某种状态开始下一步的所有的状态
         public Set opreation(){
             Set res=new HashSet();

             //开始倒酒
             for(int i=0;i<bottle.length;i++){
                 for(int j=0;j<bottle.length;j++){
                     if(i==j) continue; //不倒自己
                     if(bottle[i]==0) continue;//自己是空的 不倒
                     if(bottle[j]==full[j]) continue;//对方是满的 不倒

                     Status t=new Status(bottle[0], bottle[1], bottle[2]);
                     t.from=this;//从自己这个状态开始变化

                     //真的开始倒酒了                     t.bottle[j]+=t.bottle[i];
                     t.bottle[i]=0;
                     if(t.bottle[j]>full[j]){//装不下了
                         t.bottle[i]=t.bottle[j]-full[j];//满的倒回去
                         t.bottle[j]=full[j];
                     }              
                     res.add(t);
                 }
             }
             return res;
         }

         //是否含有某种状态
         public boolean has2(int x){
            int index=0;
            if (bottle[0]==x) index++;
            if (bottle[1]==x) index++;
            if (bottle[2]==x) index++;
            return index==2?true:false;
         }

         public Status getFrom() {
            return from;
        }

         public String toString(){
                return "<" + bottle[0] + "," + bottle[1] + "," + bottle[2] + ">";
        }

        public int hashCode() {
            return 100;
        }

        public boolean equals(Object obj) {
            Status x=(Status)obj;
            return bottle[0]==x.bottle[0]&&bottle[1]==x.bottle[1]&&bottle[2]==x.bottle[2];
        }
    }

    public static void main(String[] args) {
        Set<Status> all=new HashSet<Status>();//存放所有结果状态
        all.add(new Status(12, 0, 0));

        for(;;){
            Set newset=new HashSet();

            for(Status x:all){//所有上一种状态产生所有下一种状态
                Set t = x.opreation();
                newset.addAll(t);
            }

            if(all.containsAll(newset)) break;//出口
            all.addAll(newset);
        }

        LinkedList<Status> list=new LinkedList<Status>();//存放有6的一溜

        for(Status k:all){
            if(k.has2(6)){
                while(k!=null){    
                    list.push(k);
                    k=k.getFrom();//从终止状态开始往上追溯
                }
            }
        }   
        //输出
        while(!list.isEmpty()){
            System.out.println(list.pop());
        }
    }    
}

这个解法找到的其实是最优解,至于为什么呢,其实利用set的方法十分巧妙,结果集set里随着一次次的分酒一次次地扩增,当第一次出现含有两个6的状态的时候,再往前追溯,步骤是最少的!因为这个我们想要的状态是第一次出现.
假如我们每次都打印出all集合,可以知道,当第一次找到含有两个6状态的时候程序并没有结束,因为还没有找到所有的状态.
而后面的状态再进行分酒时,仍有可能产生两个6的状态,但是想要加入set集合的时候就行不通了,所以此程序只输出最早加入的那一个解,并且是最优的.
当然这种算法并不能输出所有的解,如果要得到所有的解,我们可以采用以下算法,这种算法借鉴了图的深度搜索(DFS)以及回溯的技巧,需要注意的是,和8皇后问题一样,需要回溯的时机有两个,出错的时候和找到某一组解的时候.

代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Oil {
    int[] full = new int[3]; //满状态 容量
    int[] bottle = new int[3]; //瓶子的状态
    int target = 0; //目标
    List<int[]> res = new ArrayList<int[]>();//存放结果

    public void opreation(int[] bottle) {
        for(int i=0;i<3;i++) {
            for(int j=1;j<3;j++){//每个瓶子都不往自己倒 总共6种可能性
                int[] temp = bottle.clone();//每次循环都创建临时数组 
                int to=(i+j)%3;//(i+j)%3 是除每种i瓶子外其他两个瓶子的序号,即要倒的目标
                if(temp[i]==0) continue;//自己是空的 不倒
                if(temp[to]==full[to]) continue;//对方是满的 不倒

                //开始倒酒
                temp[to]+=temp[i];
                temp[i]=0;
                if(temp[to]>full[to]){//装不下了
                    temp[i]=temp[to]-full[to];//满出来的部分倒回去
                    temp[to]=full[to];
                }

                if(had(temp)) continue;//检测是否已经存在相同状态,防止重复

                res.add(temp);//添加到结果链表
                if(has2(temp))    return;//如果找到有两个想要的状态的结果就返回
                opreation(temp);//继续下一次分酒
                res.remove(res.size()-1); //回溯 仔细体会
            }
        }
    }

    //是否以及含有状态
    private boolean had(int[] bottlex) {
        for(int[] e:res)
            if(e[0]==bottlex[0]&&e[1]==bottlex[1]&&e[2]==bottlex[2]) return true;
        return false;
    }

    //检测找到结果
    private boolean has2(int[] bottle) {
        int index=0;
        for(int i=0;i<bottle.length;i++)        
            if(bottle[i]==target) index++;        
        if(index==2){
            show(res);//输出
            res.remove(res.size()-1);//回溯
            return true;
        }
        return false;
    }
    //打印
    private void show(List<int[]> res) {
        for(int[] e:res) {
            System.out.println(e[0] + "," + e[1] + "," + e[2]);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Oil o = new Oil();
        Scanner scanner = new Scanner(System.in);
        String s =""; 
        if(scanner.hasNext()) {
            s = scanner.nextLine();
        }
        String[] data = s.split(",");
        int[] d = new int[data.length];
        for(int i=0;i<data.length;i++){
            d[i] = Integer.parseInt(data[i]);
        }
        o.full = new int[]{d[0],d[1],d[2]};
        o.bottle = new int[]{d[3],d[4],d[5]};
        o.target = d[6];
        o.res.add(new int[]{d[3],d[4],d[5]});//添加初始状态
        o.opreation(o.bottle);
    }

}

显然,按照深度搜索并不能有效地找到最优解.上面两种算法都是比较巧的,我也比较喜欢.
如果要同时找到所有解和最优解,用图的广度搜索(BFS)会很方便,这也是网上采用的最多的,代码到处都有,就不写了.