贪心算法-泊松分酒问题

讲这道题纯粹就是比较好玩,就记录一下.泊松分酒是很著名的一道题,讲的是假设某人有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)会很方便,这也是网上采用的最多的,代码到处都有,就不写了.