泊松分酒

题目如下:

泊松是法国数学家、物理学家和力学家。他一生致力科学事业，成果颇多。有许多著名的公式定理以他的名字命名，比如概率论中著名的泊松分布。


    有一次闲暇时，他提出过一个有趣的问题，后称为：“泊松分酒”。在我国古代也提出过类似问题，遗憾的是没有进行彻底探索，其中流传较多是：“韩信走马分油”问题。


    有3个容器，容量分别为12升，8升，5升。其中12升中装满油，另外两个空着。要求你只用3个容器操作，最后使得某个容器中正好有6升油。


    下面的列表是可能的操作状态记录：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5


    每行3个数据，分别表示12，8，6升容器中的油量


    第一行表示初始状态，第二行表示把12升倒入8升容器后的状态，第三行是8升倒入5升，...


    当然，同一个题目可能有多种不同的正确操作步骤。


    本题目的要求是，请你编写程序，由用户输入：各个容器的容量，开始的状态，和要求的目标油量，程序则通过计算输出一种实现的步骤


    例如，用户输入：
12,8,5,12,0,0,6


    用户输入的前三个数是容器容量（由大到小），接下来三个数是三个容器开始时的油量配置，最后一个数是要求得到的油量（放在哪个容器里得到都可以）


    则程序可以输出（答案不唯一，只验证操作可行性）：
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5

解析：我这里用的是回溯法，假设现在三个酒杯分别标记为A,B,C,则对于一个状态有六种分酒方法：A->B,A->C,B->A,B->C,C->A,C->B,根据这种思想构造出来

的搜索树每一层有六个节点，每个节点对应一种分酒方法，进行一次分酒之后，便是一个新的状态，此时递归进行六种分酒方法，使用回溯法自然就需要明确

回溯条件，这里我的回溯条件分为两种：第一种，当无法进行分酒时回溯（如A->B，此时如果A是空的，或者B是满的，则分酒无法进行），第二种，当分酒之

后的状态之前已经出现过，则回溯（否则会永无止境得搜索）。

java代码如下：

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

public class ys_10 {
	//分酒
	public static void main(String[] args) {
		
		new ys_10().new answer(12,8,5,12,0,0,6);
	}
	private class answer{
		//保存每一次的结果
		private int[] result=new int[3];
		//最终存在的数字
		private int last=0;
		//初始大小
		private int[] size=new int[3];
		//历史记录
		private List history=new ArrayList();
		//过程
		private List course=new ArrayList();
		public answer(int a1,int a2,int a3,int a4,int a5,int a6,int a7){
			size[0]=a1;
			size[1]=a2;
			size[2]=a3;
			result[0]=a4;
			result[1]=a5;
			result[2]=a6;
			last=a7;
			//添加初始记录
			addHistory();
			addCourse();
			process();
		}
		public void process(){
			if(isLast()){
				//输出结果
				outputCourse();
				return;
			}
			int one,two,three;
			one=result[0];
			two=result[1];
			three=result[2];
			int[] temp={1,2,0,2,0,1};
			for(int i=0;i<6;i++){
				//六种情况分别为：A->B,A->C,B->A,B->C,C->A,C->B
				if(!move(i/2,temp[i])){
					//移动失败
					continue;
				}
				//是否存在该记录-》存在
				if(isInHistory()){
					//恢复原来的状态
					result[0]=one;
					result[1]=two;
					result[2]=three;
					//这里的剪枝很重要，否则会一直搜索下去
					continue;
				}else{
					addHistory();
					//添加有效记录
					addCourse();
				}
				//处理下一层
				process();
				//应该恢复到原来状态
				result[0]=one;
				result[1]=two;
				result[2]=three;
				removeCourse();
			}
		}
		//通过a杯装满b杯
		public boolean move(int a,int b){
			//a酒杯是空酒杯
			if(result[a]==0)return false;
			//b酒杯是满酒杯
			if(result[b]==size[b])return false;
			
			//b酒杯的剩余空间大于等于a酒杯的
			if(size[b]-result[b]>=result[a]){
				result[b]+=result[a];
				result[a]=0;
			}else{
				//a酒杯减去b酒杯的剩余容量
				result[a]-=(size[b]-result[b]);
				//b酒杯装满
				result[b]=size[b];
			}
			return true;
		}
		//将当前状态添加到记录中
		private void addHistory(){
			String his=result[0]+","+result[1]+","+result[2];
			history.add(his);
		}
		//当前状态是否存在于历史记录中
		private boolean isInHistory(){
			//待优化，可以用位运算
			String his=result[0]+","+result[1]+","+result[2];
			return history.contains(his);	
		}
		//添加过程
		private void addCourse(){
			for(int i=0;i<result.length;i++){
				course.add(result[i]);
			}
		}
		//移除过程
		private void removeCourse(){
			int length=course.size();
			for(int i=length-1;i>length-4;i--){
				course.remove(i);
			}
		}
		//当前结果是否是最终结果了
		private boolean isLast(){
			for(int i=0;i<result.length;i++){
				if(result[i]==last){return true;}
			}
			return false;
		}
		//输出最终结果
		private void outputCourse(){
			
			for(int i=0;i<course.size();i++){
				
				if(i%3==2){
					System.out.println(course.get(i));
				}else{
					System.out.print(course.get(i)+",");
				}

			}
			System.out.println("========================");
		}
	}
}

输出结果：

12,0,0
4,8,0
0,8,4
8,0,4
8,4,0
3,4,5
3,8,1
11,0,1
11,1,0
6,1,5
========================
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
========================