状态树搜索算法-------------抽象问题与建模思想(三只水桶分水问题)

我的天！！！！！！！！！！！！！！！！！！！！！！！

我终于把这该死的三个水桶把水分成两半了！！！！！！！！！！！！

今天我用下午和晚上的时间研究用三个水桶8L,5L,3L把8L水分成两份(4L)

晚上我从八点种时间开始写算法，写了4个小时，除了其中半个小时的洗澡，我一直在想，该如何实现。。。。。。

其中被那个备忘录卡了我一个半小时！！！！！！！！(谢天谢地，我终于把它搞出来了，现在我欣喜的心情无以复加！！！！！！！！！！)

好了，情感发泄完了，该步入正题了，总结我今天的算法学习。

今天看《算法的乐趣》第五章，作者提出问题：把三桶个水桶等分8升水的问题，有8,5,3L的水桶分8升水，最后的结果要在8L水桶和5L水桶中分别有4L水。

首先要定义问题的解，并分析解空间范围和拓扑结构，然后根据解空间的范围和拓扑结构设计遍历搜索算法。

建立数学模型，根节点为初始状态，叶子节点可能是最终状态，也可能是某个无法转换的最终中间状态，有多少个最终状态叶子节点就要多少种答案。

现在是12点17分，室友在聊天，可能会打错几个字，大家不要介意。

状态的数学模型与状态树：状态的数学模型可以用一个一维数组存放，状态树就是建立起节点与节点之间的联系。

倒水动作的数学模型：合法的倒水动作包含3个要素：倒出水的桶、接收水的桶、倒水的体积。{from,to,water}

搜索算法：确定状态树模型后，第二个重要的问题是：状态树的搜索算法。

可用深度优先也可以广度优先，我写的是深度优先。

状态树的搜索就是对整个树进行遍历，其中还暗含了状态的生产。

状态树的剪枝和重复状态的判断

为了避免状态树的重复和环形死循环，一定要有备忘录。

我就是在处理备忘录的时候没有理解作者的思想，所以出了bug。

后来我用往前遍历，终于成功解决了，得出了16个答案，但是时间原因，我就不写输出过程的算法了。

下面是我的实现代码:

主类，创建状态树对象，传入一个根节点

package 状态数搜索算法;

public class Main {
	public static void main(String[] args) {
		Main ma = new Main();
		ma.initMain();
	}
	public void initMain(){
		DumpWater dw = new DumpWater();
		int[] str = {8,0,0};
		StateNode state = new StateNode(str);
		dw.SearchState(state);
	}
}

递归倒水算法：

package 状态数搜索算法;

import java.util.Vector;

public class DumpWater {
	public int count = 0;
	public void SearchState(StateNode state){//检查每一个状态是否是最终状态，不是的话就继续检索
		if(state.IsFinalState()){//判断节点是否为最终状态
			count++;
			System.out.println(count+":"+"Succeed!");
			return ;
		}
		for(int j=0;j<state.bucket.length;j++){
			for(int i=0;i<state.bucket.length;i++){
				SearchStateAction(state, i, j);
			}
		}
	}
	public void SearchStateAction(StateNode state,int from,int to){
		if(state.CanTakeDumpAction(from, to)){//判断当前状态能否倒水
			StateNode next = new StateNode(state.bucket);
			next.back = state;
			boolean bDump = state.Dump_Wate(from, to, next);
			if( bDump && !Tool.IsProcessedState(next) ){
				SearchState(next);
			}
		}
	}
	
}

状态树节点：

package 状态数搜索算法;

public class StateNode {//水桶节点
	public int[] bucket = new int[3];//水桶
	public StateNode back;
	public int getMax(int bucket){
		if( bucket == 0 ){
			return 8;
		}else if( bucket == 1 ){
			return 5;
		}else if( bucket == 2 ){
			return 3;
		}
		return 0;
	}
	public StateNode(int[] str){
		this.bucket[0] = str[0];
		this.bucket[1] = str[1];
		this.bucket[2] = str[2];
	}
	public boolean Dump_Wate(int from,int to,StateNode next){
		int dump_Water = next.getMax(to) - next.bucket[to];
//		System.out.println(from+"倒去"+to+"  dump_Water-- >"+dump_Water);
		if( next.bucket[from] >= dump_Water ){
			next.bucket[to] = next.bucket[to] + dump_Water;
			next.bucket[from] = next.bucket[from] - dump_Water;
		}else{
			next.bucket[to] = next.bucket[to] + next.bucket[from];
			dump_Water = next.bucket[from];
			next.bucket[from] = 0;
		}
		if( dump_Water > 0 ){
			next.SetAction(dump_Water, from, to,next);
			return true;
		}
		return false;
	}
	
	public boolean IsFinalState(){
		if( bucket[0] == 4 && bucket[1] == 4 && bucket[2] == 0){//判断是否为最终状态
			return true;
		}else{
			return false;
		}
	}
	/**
	 * 判断水桶编号是否在012
	 * from 和 to 不相同
	 * from没满，to不为空
	 * @param from
	 * @param to
	 * @return
	 */
	public boolean CanTakeDumpAction(int from,int to){
		if( from>=0 && from<3 && to>=0 && to<3 ){//判断水桶编号是否在0、1、2中
			if( (from != to) && 
					IsBucketEmpty(from)
					&& IsBucketFull(to)){//倒水水桶不是自己，倒水水桶没空，被倒水桶不满，可以倒
				return true;
			}
		}
		return false;
	}
	/**
	 * 判断水桶是否为空
	 * 有水就返回true
	 * 空就返回false
	 * @param from
	 * @return
	 */
	public boolean IsBucketEmpty(int from){//判断倒水的桶是否为空
		if(bucket[from] > 0){//如果水桶有水，返回true
			return true;
		}else{
			return false;//空返回false
		}
	}
	/**
	 * 判断水桶是否已经装满
	 * 如果满了，返回false
	 * 如果可以装就返回true
	 */
	public boolean IsBucketFull(int to){//判断被倒水的水桶是否已满
		if(to == 0 && bucket[to]<8 && bucket[to]>=0 ){//如果水桶是一号，水量大于0且小于8，没满，返回true
			return true;
		}else if(to == 1 && bucket[to]<5 && bucket[to]>=0 ){//2号水桶，水量大于0小于8，没满，返回true
			return true;
		}else if(to == 2 && bucket[to]<3 && bucket[to]>=0 ){//3号水桶，水量大于0小于3，没满，返回true
			return true;
		}
		return false;
	}
	/**
	 * ???
	 * @param dump_Water
	 * @param from
	 * @param to
	 * @param next
	 */
	public void SetAction(int dump_Water,int from,int to,StateNode next){
		
	}
	public String getText(StateNode state){
		String s1 = Integer.toString(state.bucket[0]);
		String s2 = Integer.toString(state.bucket[1]);
		String s3 = Integer.toString(state.bucket[2]);
		String s = s1 + s2 + s3;
		return s;
	}
}

工具类：

package 状态数搜索算法;

import java.util.HashMap;
import java.util.Vector;

public class Tool {
	public static Vector<String> vector = new Vector<String>();
	public static boolean IsProcessedState(StateNode state){
		StateNode current = state ;
		while( state.back != null ){//逐一对比当前状态跟上面状态
			if(current.getText(current).contains(state.back.getText(state.back))){
				return true;
			}
			state = state.back;
		}
		
		return false;
	}
	
}

这个算法作者用C++做的，我用java实现。

下面是作者的博客，跟书上差不多，大家参考。

http://blog.csdn.net/orbit/article/details/6596521

十二点半了，我该下了。明天有课