倒油问题，广度优化搜索，java

import cn.hncu.sreach.putOil.common.Bucket;
import cn.hncu.sreach.putOil.common.DumpCase;
import cn.hncu.sreach.putOil.common.MySet;

/* 有一位厨师要从盛12斤油（a桶）的桶中倒出6斤油来，可是手边只有盛8斤油（b桶）和盛5斤油（c桶）的两个桶，问如何操作才能将6斤取出来呢？
 *  本题采用广度优化搜索解题：每倒一次油，就有可能有6种方案，每倒一次就判断有没有出现6斤的情况，若出现就记录下来，然后继续广搜，直到所有的情况全部搜完。
 *                       下面有详细的注释。
 */
public class DumpOilBFS {
	public static void main(String[] args) {
		Bucket[] buckets = new Bucket[3]; // new数组长度为3，表示3个桶
		buckets[0] = new Bucket(12, 12); // 第一桶的属性，桶的大小为12斤，现有12斤
		buckets[1] = new Bucket(8, 0); // 第一桶的属性，桶的大小为8斤，现有0斤
		buckets[2] = new Bucket(5, 0); // 第一桶的属性，桶的大小为5斤，现有0斤
		DumpCase u = new DumpCase(buckets); // new DuampCase,用来表示现在三个桶的状态
		MySet caseSet = new MySet(); // new MySet，用来表示已经出现过的三个桶的状态，后面用来防止走重复的步骤
		caseSet.add(u);
		CaseQueue que = new CaseQueue(); // 队列，用来把当前的三个桶的状态和此时caseSet的状态装进去
		que.enqueue(u, caseSet);
		bfs(que); // 进入广度优化搜索

	}

	// 广度优化搜索
	private static void bfs(CaseQueue que) {
		while (!que.isEmpty()) { // 如果队列为空，直接退出
			Q q = que.dequeque(); // 从队列中取出一个元素q
			DumpCase u = que.getDumpCase(q); // 从q中提取出DumpCase
			MySet caseSet = que.getMySet(q); // 从q中提取出DumpCase
			// 判断是否出现了某一个桶中的油为6斤，退出循环
			if (u.buckets[0].now == 6 || u.buckets[1].now == 6) {
				print(u, caseSet); // 输出路径
				continue; // 此处不能break，不然只会出来一种情况
				// break;
			}
			DumpCase temp = new DumpCase(u);// 此处备份一次，以便后面的还原
			// 此处是广搜的核心
			for (int i = 0; i < temp.buckets.length; i++) {
				for (int j = 0; j < temp.buckets.length; j++) {
					if (i == j) {//不能自己和自己倒
						continue;
					}
					int inCanDump = temp.buckets[i].canOut(); //看这次能倒多少
					if (inCanDump > temp.buckets[j].canIn()) { //判断能倒的量是否大于接收的量
						inCanDump = temp.buckets[j].canIn();  //如果大于的话，那么能把i中的全部倒出来
					}
					if (inCanDump == 0) { //如果倒进去
						continue;
					}
					//开始倒油,把该减的减了，该加的加了
					temp.buckets[i].out(inCanDump);
					temp.buckets[j].in(inCanDump);
					//判断倒完之后以前是否出现过这样的情况
					if (caseSet.contains(temp)) {
						//若存在，则还原
						temp.buckets[i].in(inCanDump);
						temp.buckets[j].out(inCanDump);
						continue;
					}
					DumpCase v = new DumpCase(temp);
					v.parent = u;  //记录父节点
					caseSet.add(v);//记录到已经搜索的结点集合当中
					que.enqueue(v, caseSet);//加入到广搜队列当中
					//必须还原，以便从该结点继续尝试其它路径
					temp.buckets[i].in(inCanDump);
					temp.buckets[j].out(inCanDump);

				}
			}

		}
	}
	//输出路径（按倒序输出来），下一个需要输出的是上一个的父节点
	private static void print(DumpCase u, MySet caseSet) {
		MySet set = new MySet();
		set.add(u);
		DumpCase d = u.parent;
		while (d != null) {
			set.add(d);
			d = d.parent;
		}
		Object[] obj = set.getAll();
		for (int i = obj.length - 1; i >= 0; i--) {
			if (i > 0) {
				System.out.print(obj[i] + " --->>");
			} else {
				System.out.println(obj[i]);
			}
		}
	}
}
//用来装DumpCase和MySet的对象
class Q {
	public DumpCase d;
	public MySet m;
	//构造函数
	public Q(DumpCase d, MySet m) {
		this.d = d;
		this.m = new MySet(m);
	}

	public DumpCase getD() {
		return d;
	}

	public MySet getM() {
		return m;
	}
}
//队列（队列中元素是捆绑了DumpCase和MySet的对象）
class CaseQueue {
	private Q[] qs = new Q[100];
	DumpCase u = null;
	MySet set = null;
	int end = 0; //队列指针，表示队列中元素个数

	// 入队列
	public int enqueue(DumpCase u, MySet caseSet) {
		qs[end++] = new Q(u, caseSet);
		return end;
	}
	
	public DumpCase getDumpCase(Q q) {
		return q.d;
	}

	public MySet getMySet(Q q) {
		return q.m;
	}

	// 出队列
	public Q dequeque() {
		if (isEmpty()) {
			return null;
		}
		Q q = qs[0]; //每次都是弹出队列的第一个元素
		//所有元素往前面移一位
		if (end > 1) {
			for (int i = 0; i < end; i++) {
				qs[i] = qs[i + 1];
			}
		}
		end--;
		return q;
	}
	//判断是否为空
	public boolean isEmpty() {
		if (end == 0) {
			return true;
		}
		return false;
	}

}

版权声明：本文为博主原创文章，未经博主允许不得转载。