深度优先搜索例题------Java倒油

深度搜索倒油：

样题描述：有a、b、c三个油桶；a桶的容量为12斤，现有12斤油；b桶容量为8斤，现有0斤；c桶容量5斤，现有0斤。现一次只能由一个桶向另一个同倒油，问怎样才能倒出6斤油。

package cn.hncu.search.oil.dfs;

import cn.hncu.search.oil.common.Bucket;
import cn.hncu.search.oil.common.DumpCase;
import cn.hncu.search.oil.common.Myset;

public class DumpOilDFS {

	public static void main(String[] args) {
		Bucket buckets[] = new Bucket[3];
		buckets[0] = new Bucket(12, 12);
		buckets[1] = new Bucket(8, 0);
		buckets[2] = new Bucket(5, 0);
		DumpCase u = new DumpCase(buckets);
		
		Myset caseSet = new Myset();
		caseSet.add(u);
		dfs(u,caseSet);
	}
	public static void print(DumpCase u,Myset caseSet){
		Myset set = new Myset();
		set.add(u);
		DumpCase d = u.getParent();
		while(d!=null){
			set.add(d);
			d = d.getParent();
		}
		System.out.println("------------");
		Object objs[] = set.getAll();
		for(int i=objs.length-1; i>=0; i--){
			DumpCase v = (DumpCase) objs[i];
			System.out.println(v.getBuckets()[0].now+","+v.getBuckets()[1].now+","+v.getBuckets()[2].now);
		}
		
	}
	
	public static void dfs(DumpCase u0, Myset caseSet){
		//递归鸿沟
		for(Bucket bucket: u0.getBuckets()){
			if(bucket.now==6){
				//System.out.println("find a case");
				print(u0,caseSet);
				return;
			}
		}
		
		
		int n = u0.getBuckets().length;//桶的个数
		DumpCase u = new DumpCase(u0);
		//用备份节点去搜
		//遍历所有的DumpCase: 依次让桶i向j倒
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				//自己不能给自己倒
				if(i==j){
					continue;
				}
				
				//算出桶i给j倒时，能倒多少-->canDump
				int canDump = u.getBuckets()[i].canOut();
				if(u.getBuckets()[i].canOut()>u.getBuckets()[j].canIn()){
					canDump = u.getBuckets()[j].canIn();
				}
				//倒油
				u.getBuckets()[i].out(canDump);
				u.getBuckets()[j].in(canDump);
				
				//System.out.println(u.getBuckets()[0].now+","+u.getBuckets()[1].now+","+u.getBuckets()[2].now);
				//判断该情况是否已经出现过了//如果存在，要还原(把油倒回去)
				if(caseSet.contains(u)){
					//把油还回去
					u.getBuckets()[i].in(canDump);
					u.getBuckets()[j].out(canDump);
					continue;
				}
				
				//经过上面的哨兵，说明这样倒可以
				DumpCase v = new DumpCase(u);
				v.setParent(u0);
				caseSet.add(v);
				//System.out.println(v.getBuckets()[0].now+","+v.getBuckets()[1].now+","+v.getBuckets()[2].now);
				dfs(v,caseSet);
				
				//再倒回去，以重新进行下一个邻居的遍历
				u.getBuckets()[i].in(canDump);
				u.getBuckets()[j].out(canDump);
				
			}
		}
	}
}

package cn.hncu.search.oil.common;

public class Bucket {
	public int max;
	public int now;

	public Bucket(int max, int now) {
		this.max = max;
		this.now = now;
	}
	public void in(int a){
		now += a;
	}
	public void out(int a){
		now -=a;
	}
	public int canIn(){
		return max-now;
	}
	public int canOut(){
		return now;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + max;
		result = prime * result + now;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Bucket other = (Bucket) obj;
		if (max != other.max)
			return false;
		if (now != other.now)
			return false;
		return true;
	}
	
}

package cn.hncu.search.oil.common;

import java.util.Arrays;

public class DumpCase {
	Bucket buckets[];
	DumpCase parent = null;

	public DumpCase() {
	}
	
	public DumpCase(Bucket buckets[]) {
		this.buckets = buckets;
	}
	
	//必须要进行深拷贝
	public DumpCase(DumpCase u) {
		this.buckets = new Bucket[ u.getBuckets().length ];
		for(int i=0; i<u.getBuckets().length;i++){
			buckets[i] = new Bucket(0,0);
			buckets[i].max = u.getBuckets()[i].max;
			buckets[i].now = u.getBuckets()[i].now;
		}
	}

	public Bucket[] getBuckets() {
		return buckets;
	}

	public DumpCase getParent() {
		return parent;
	}

	public void setParent(DumpCase parent) {
		this.parent = parent;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + Arrays.hashCode(buckets);
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		DumpCase other = (DumpCase) obj;
		if (!Arrays.equals(buckets, other.buckets))
			return false;
		return true;
	}
	
	//※1 用“特征串”来代表整个对象，如果特征串相等，则表示是相等的对象。这样在比较对象时，性能就提高了
	public String toString(){
		return "A="+buckets[0].now+",B="+buckets[1].now+",C="+buckets[2].now;
	}
	
}

package cn.hncu.search.oil.common;

public class Myset {
    private Object[] objs= new Object[0];
    public boolean contains(Object obj){
    	for(Object tmp: objs){
    		if(tmp.equals(obj)){
    			return true;
    		}
    	}
    	return false;
    }
    public boolean add(Object obj){
    	if(contains(obj)){
    		return false;
    	}
    	Object[] tempObjs = new Object[objs.length+1];
    	System.arraycopy(objs, 0, tempObjs, 0, objs.length);
    	tempObjs[objs.length] = obj;
    	objs = tempObjs;
    	return true;
    }
    public Object[] getAll(){
    	return objs;
    }
    public int size(){
    	return objs.length;
    }
}