BFS——NYOJ 21 三个水杯

三个水杯

时间限制：1000 ms  |  内存限制：65535 KB

难度：4

描述

给出三个水杯，大小不一，并且只有最大的水杯的水是装满的，其余两个为空杯子。三个水杯之间相互倒水，并且水杯没有标识，只能根据给出的水杯体积来计算。现在要求你写出一个程序，使其输出使初始状态到达目标状态的最少次数。

输入

第一行一个整数N(0<N<50)表示N组测试数据
接下来每组测试数据有两行，第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的体积。
第二行给出三个整数E1 E2 E3 （体积小于等于相应水杯体积）表示我们需要的最终状态

输出

每行输出相应测试数据最少的倒水次数。如果达不到目标状态输出-1

样例输入

26 3 14 1 19 3 27 1 1

样例输出

3-1

---

唉...这道题写了好久啊！

简单的宽度优先搜索，三个水杯之间的相互倒水如下图6种情况：

对于每一次倒水都会引起三个水杯水量状态的改变，这样就可以得到如下的一个解空间树：

按照上图中得到解空间树的方法，代码如下：

---

[cpp] view plain copy

 print?

1. #include <cstdio>  
2. #include <memory.h>  
3. #include <queue>  
4.   
5. using namespace std;  
6.   
7. #define EMPTY    0  
8.   
9. struct data_type  
10. {  
11.     int state[3];  
12.     int step;  
13. };  
14.   
15. int cupCapacity[3], targetState[3];  
16.   
17. bool visited[100][100][100];  
18.   
19. bool AchieveTargetState(data_type current)  
20. {  
21.     for (int i = 0; i < 3; i++)  
22.     {  
23.         if (current.state[i] != targetState[i])  
24.         {  
25.             return false;  
26.         }  
27.     }  
28.     return true;  
29. }  
30.   
31. void PourWater(int destination, int source, data_type &cup)  
32. {  
33.     int waterYield = cupCapacity[destination] - cup.state[destination];  
34.     if (cup.state[source] >= waterYield)  
35.     {  
36.         cup.state[destination] += waterYield;  
37.         cup.state[source] -= waterYield;  
38.     }  
39.     else  
40.     {  
41.         cup.state[destination] += cup.state[source];  
42.         cup.state[source] = 0;  
43.     }  
44. }  
45.   
46. int BFS(void)  
47. {  
48.     int i, j, k;  
49.     data_type initial;  
50.     queue<data_type> toExpandState;  
51.   
52.     memset(visited, false, sizeof(visited));  
53.     initial.state[0] = cupCapacity[0];  
54.     initial.state[1] = initial.state[2] = 0;  
55.     initial.step = 0;  
56.     toExpandState.push(initial);  
57.     visited[initial.state[0]][0][0] = true;  
58.   
59.     while (!toExpandState.empty())  
60.     {  
61.         data_type node = toExpandState.front();  
62.         toExpandState.pop();  
63.         if (AchieveTargetState(node))  
64.         {  
65.             return node.step;  
66.         }  
67.         for (i = 0; i < 3; i++)  
68.         {  
69.             for (j = 1; j < 3; j++)  
70.             {  
71.                 k = (i+j)%3;  
72.                 if (node.state[i] != EMPTY && node.state[k] < cupCapacity[k])  
73.                 {  
74.                     data_type newNode = node;  
75.                     PourWater(k, i, newNode);  
76.                     newNode.step = node.step + 1;  
77.                     if (!visited[newNode.state[0]][newNode.state[1]][newNode.state[2]])  
78.                     {  
79.                         visited[newNode.state[0]][newNode.state[1]][newNode.state[2]] = true;  
80.                         toExpandState.push(newNode);  
81.                     }  
82.                 }  
83.             }  
84.         }  
85.     }  
86.     return -1;  
87. }  
88.   
89. int main(void)  
90. {  
91.     int testNum;  
92.     scanf("%d", &testNum);  
93.     while (testNum -- != 0)  
94.     {  
95.         scanf("%d%d%d", &cupCapacity[0], &cupCapacity[1], &cupCapacity[2]);  
96.         scanf("%d%d%d", &targetState[0], &targetState[1], &targetState[2]);  
97.         printf("%d\n", BFS());  
98.     }  
99.     return 0;  
100. }