隐式图倒水问题

问题描述：

倒水问题 “fill A” 表示倒满A杯，"empty A"表示倒空A杯，“pour A B” 表示把A的水倒到B杯并且把B杯倒满或A倒空。

input:
输入包含多组数据。每组数据输入 A, B, C 数据范围 : 0 < A <= B 、C <= B <=1000 、A和B互质。
output:
你的程序的输出将由一系列的指令组成。这些输出行将导致任何一个罐子正好包含C单位的水。每组数据的最后一行输出应该是“success”。输出行从第1列开始，不应该有空行或任何尾随空格。

解题思路：

该题目是隐式图问题，只给出了起始状态和最终状态，让我们求出一条从起始到终点可行的过程，在该问题中，存在很多中间状态，有些状态是可行的，有些状态是不可行的，则我们可以将这些状态看成一个图的中间点，起始状态和最终状态看成图的起点和终点，则我们可以通过bfs来找到一条可行路径。

在中间状态中，无非执行六种操作，fill A，fill B，empty A，empty B，pour A B，pour B A。则我们可以通过bfs，来遍历这六种操作。

对于每一个状态，我们可以通过一个结构体来存储，其中包括A的容量a，B的容量b，以及执行到这一个状态的执行操作，通过一个string类型的变量来记录。并且重载了"=“和"＜”，以便于使用stl中的map。

我们使用了stl中的map来对图中的每一个状态进行标记，并且记录该状态的上一个状态。在bfs中，首先要有一步特判终点，如果到达终点，则退出，记录终点的状态。若没有对6种情况进行搜索，对于得到的每一个状态，我们都要使用map中的count操作，来判断该状态存在不存在，若不存在，将其压入队列，并且通过map记录其上一个状态。

输出时，使用vector输出，通过map，将终点的上一个状态找出，这样循环，一直到起始状态，就能找到每一个状态，将其插入vector数组，然后将vector数组进行倒序输出。

解题总结：

对于隐式图问题，只给出了起始和终点两种状态，那么首先我们要考虑中间可能会执行的操作，我们可以想象成中间的每一种状态相当于图的一个节点，那我们就可以使用bfs进行广度优先搜索，直到终点状态为止，这样我们就找到一条从起始到终点状态的一种可行性路径。

代码：

#include<iostream>
#include<queue>
#include<string>
#include<vector>
#include<map>
using namespace std;
struct rest {//用来储存每一种状态
	int a;
	int b;
	string tishi;
	rest & operator = (const rest& r) {
		a = r.a;
		b = r.b;
		tishi = r.tishi;
		return *this;
	}
	bool operator < (const rest & r)const {
		if (a != r.a) return a < r.a;
		return b < r.b;
	}
};
queue<rest> store;

void chazhao(int f, int g, int h)
{
	map<rest, rest> mm;
	rest temp;
	rest end;
	temp.a = 0;
	temp.b = 0;
	temp.tishi = "";
	store.push(temp);
	while (!store.empty())//bfs
	{
		rest flag = store.front();
		store.pop();
		if (flag.a == h || flag.b == h) //特判终点
		{
			end = flag;
			break;
		}
		//六种可能情况
		if (flag.a > 0)
		{
			rest r9;
			r9.a = 0;
			r9.b = flag.b;
			r9.tishi = "empty A";
			if (mm.count(r9) == 0)  //判断该状态是否存在
			{
				store.push(r9);
				mm[r9] = flag;
			}

		}
		if (flag.b > 0)
		{
			rest r0;
			r0.a = flag.a;
			r0.b = 0;
			r0.tishi = "empty B";
			if (mm.count(r0) == 0)
			{
				store.push(r0);
				mm[r0] = flag;
			}
		}
		if (flag.a < f) {

			rest r1;
			r1.a = f;
			r1.b = flag.b;
			r1.tishi = "fill A";
			if (mm.count(r1) == 0)
			{
				store.push(r1);
				mm[r1] = flag;
			}
			if (flag.b != 0)
			{
				rest r8;
				if (flag.a + flag.b > f)
				{
					r8.a = f;
					r8.b = flag.a + flag.b - f;
				}
				else
				{
					r8.a = flag.a + flag.b;
					r8.b = 0;
				}
				r8.tishi = "pour B A";
				if (mm.count(r8) == 0)
				{
					store.push(r8);
					mm[r8] = flag;
				}
			}
		}
		if (flag.b < g)
		{

			rest r2;
			r2.a = flag.a;
			r2.b = g;
			r2.tishi = "fill B";
			if (mm.count(r2) == 0)
			{
				store.push(r2);
				mm[r2] = flag;
			}
			if (flag.a != 0)
			{
				rest r7;
				if (flag.b + flag.a > g)
				{
					r7.b = g;
					r7.a = flag.a + flag.b - g;
				}
				else
				{
					r7.b = flag.a + flag.b;
					r7.a = 0;
				}
				r7.tishi = "pour A B";
				if (mm.count(r7) == 0)
				{
					store.push(r7);
					mm[r7] = flag;
				}
			}

		}
	}
	vector<string> p;
	p.push_back("success");
	while ((end.a != 0 || end.b != 0))   //将这条成功路径的所有操作存到数组p中
	{
		p.push_back(end.tishi);
		rest tt;
		tt = mm[end];
		end = tt;
	}
	for (int i = p.size()-1; i >= 0; i--)
	{
		cout << p[i] << "\n";
	}
	while (!store.empty())//清空队列
	{
		store.pop();
	}
}
int main()
{
	int A, B, C;
	while (cin >> A >> B >> C)
	{
		chazhao(A, B, C);
	}
}