算法分析与设计—— 遍历问题【给定一个装满水的8品脱壶】

问题：
西蒙.丹尼斯.泊松是著名的法国数学家和物理学家。据说在他遇到某个古老的谜题之后，就开始对数学感兴趣了，这个谜题是这样的：给定一个装满水的8品脱壶以及两个容量分别为5品脱和3品脱的空壶，如何通过完全灌满或者倒空这些壶从而使得某个壶精确地装有4品脱的水。

问题分析与解决思路：
通过对问题的分析，拟采用广度优先遍历来解决该问题。由于初始状态是8品脱的壶里装满水，5品脱和3品脱的壶为空壶，我们可以先将三个壶的状态标示为：800，然后我们开始拓展这个数所有能到达的状态（括号里的水是上一状态）：350（800）、503（800），然后我们继续拓展这一状态可能到达的状态，并且不能和之前的状态出现重复，下一状态：053（350）、323（350）、530（503），继续寻找下一可能到达的状态：620（323）、233（530），继续寻找下一可能到达的状态：602（620）、251（233），继续寻找下一可能到达的状态：152（602）、701（251），继续寻找下一可能到达的状态：143（152），至此，我们已经得到了4品脱的水。

模型建立与算法描述：
我们将上述分析过程和解决的思路进一步归纳为以下步骤：
（1）将初始状态800加入遍历序列，开始遍历。
（2）首先判断是否能倒水，仅当倒水的壶为空或者被倒水的壶为满时不能倒水。
（3）判断倒水的壶是否能倒光，并更新三个壶的状态。
（4）判断是否有壶中水为4品脱，若有则结束遍历。
（5）判断该状态之前是否出现过，若未出现过，将此状态加入到遍历序列中
（6）重复（2）、（3）、（4）操作。

伪代码：

算法 pourwater(int[] nownum)
for(int i:0->3){
   for(int j:0->3){
		if(i!=j){
			if(judge_pour(i,j,nownum)){
				if (nownum[i] + nownum[j] > maxwater[j]) {
                    nownum[i] = nownum[i] - (maxwater[j] - nownum[j]);
                    nownum[j] = maxwater[j];
                 }
             else {
                    nownum[j] = nownum[i]+nownum[j];
                    nownum[i] = 0;
                  }
				if(nownum[0] == 4 || nownum[1] == 4 || nownum[2] == 4)
					结束遍历；
				if(!judge_exist(state,nownum[0] + nownum[1] +nownum[2])){
					state.add(nownum[0] + nownum[1] + nownum[2]);
                	list.add(nownum[0] + nownum[1] + nownum[2]);
				}
}
			}
		}
	}
算法 judge_pour(int index,int target,int[] num)
if(num[index]==0)//空
            return false;
        else{
            if(num[target]==maxwater[target])//满
                return false;
            else{
                return true;
            }
        }
算法 judge_exist(List<String> list, String s)
       for(String str:list){
            if(str.equals(s))
                return true;
        }
        return false;

算法实现
首先我们用一个int型数组来存储每个水壶的最大容量：8、5、3，再用两个String类型的ArrayList分别来存储广度优先遍历序列和用于广度优先遍历查找。ArrayList 是 java 集合框架中比较常用的数据结构。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。ArrayList 是支持快速访问、复制、序列化的。
在程序运行时，首先将初始状态800加入ArrayList，然后进行倒水操作，在倒水操作中再不断将下一个要遍历的序列加入ArrayList中，直到有水壶出现4品脱的水。

程序实现

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

public class A4 {
    static int[] water={8,0,0};
    static int[] maxwater={8,5,3};
    static List<String> state=new ArrayList<>();//存放广度优先遍历序列
    static List<String> list=new ArrayList<>();//用于广度优先遍历查找  存放上一个状态
    public static void main(String[] args){
        state.add(water[0]+""+water[1]+""+water[2]);//初始状态

        pour_water(water);

        for(int k=0;k<list.size();k++){
            int[] newnum={Integer.parseInt(list.get(k).charAt(0)+""),Integer.parseInt(list.get(k).charAt(1)+""),Integer.parseInt(list.get(k).charAt(2)+"")};
            pour_water(newnum);
        }
        for(String str:state){
            System.out.println(str);
        }

    }
    public static void pour_water(int[] num){

        int[] nownum=num;
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(i!=j){
                    if(judge_pour(i,j,nownum)) {
                        int m=nownum[i],n=nownum[j];
                        //如果i水壶不能倒光
                        if (nownum[i] + nownum[j] > maxwater[j]) {
                            nownum[i] = nownum[i] - (maxwater[j] - nownum[j]);
                            nownum[j] = maxwater[j];
                        }
                        // i水壶能倒光
                        else {
                            nownum[j] = nownum[i]+nownum[j];
                            nownum[i] = 0;
                        }

                        if (nownum[0] == 4 || nownum[1] == 4 || nownum[2] == 4) {
                            state.add(nownum[0] + "" + nownum[1] + "" + nownum[2]);
                            list.remove(list.size()-1);
                            return;
                        }
                        //state不存在该状态时将该状态分别加到allstate和list
                        if(!judge_exist(state,nownum[0] + "" + nownum[1] + "" + nownum[2])){
                            state.add(nownum[0] + "" + nownum[1] + "" + nownum[2]);
                            list.add(nownum[0] + "" + nownum[1] + "" + nownum[2]);
                        }

                        nownum[i]=m;
                        nownum[j]=n;
                    }
                }

            }
        }
    }

    //判断是否能倒水
    public static boolean judge_pour(int index,int target,int[] num){
        if(num[index]==0)//空
            return false;
        else{
            if(num[target]==maxwater[target])//满
                return false;
            else{
                return true;
            }
        }

    }
    //判断该状态是否已经遍历
    public static boolean judge_exist(List<String> list, String s){
        for(String str:list){
            if(str.equals(s))
                return true;
        }
        return false;
    }

}