ACM pku 3414 Pots 关于bfs的一个好题

    题目给出了两个水桶A,B,以及一个数C，其中A和B分别代表它们的容量,对
它们可以有如下操作:

1. FILL(i)        fill the pot i (1 ≤ i ≤ 2) from the tap;
2. DROP(i)      empty the pot i to the drain;
3. POUR(i,j)    pour from pot i to pot j; after this operation either the pot j is full (and there may be some water left in the pot i), or the pot i is empty (and all its contents have been moved to the pot j).

问桶里的水经过哪几个操作后能够达到C的容量。
这个题目可以用bfs把它做出来，对于两个桶的每一种状态，我们都可对它进行
六种操作，即FILL(1),FILL(2),DROP(1),DROP(2),POUR(1,2),POUR(2,1),
我们可以把它的每一种状态记录下来，一层一层的往下扩展，直到找到我们要
找的容量为止。不过这里有一个麻烦，就是要你输出得到容量C的过程。所以
对于每一个结点，我们都得对它设置一个pre指针，使它指向其父结点，等到
我们找到正确的结果之后，再沿着其父结点返回来找那条正确的路径。
具体代码如下：

1. #include <iostream>
2. #include <stack>
3. #define Len 10000
4. //#include <queue>
6. using namespace std;
8. struct Pot
9. {
10.      int x,y,step;
11.      int flag;
12. };
13. struct Node
14. {
15.      Pot data;
16.      struct Node *pre;
17. };
18. int A,B,C;
19. Node *an[Len];
20. Node nd[Len];
21. int num;
22. bool visit[110][110];
23. int head,tail;
24. stack<int> T;
26. int bfs(int x,int y)
27. {
28.       Node *s,*t,*cur;
29.       head = tail = 0;
30.       num = 0;
31.       cur = new Node;
32.       cur->data.x = x;
33.       cur->data.y = y;
34.       cur->data.flag = 0;
35.       cur->data.step = 0;
36.       cur->pre = NULL;
37.       an[head] = cur;
38.       tail++;
39.       visit[x][y] = true;
40.       while(head != tail)
41.       {
42.             s = an[head++];
43.             bool f;
44.             for(int i=1;i<=6;++i)
45.             {
46.                   f = false;
47.                   switch(i)
48.                   {
49.                         case 1:
50.                               nd[num].data.x = A;
51.                               nd[num].data.y = s->data.y;
52.                               nd[num].data.flag = 1;
54.                                break;
55.                         case 2:
56.                               nd[num].data.y = B;
57.                               nd[num].data.x = s->data.x;
58.                               nd[num].data.flag = 2;
59.                                break;
60.                         case 3:nd[num].data.x = 0;
61.                                nd[num].data.y = s->data.y;
62.                                nd[num].data.flag = 3;
63.                                break;
64.                         case 4:
65.                                nd[num].data.x = s->data.x;
66.                                nd[num].data.y = 0;
67.                                nd[num].data.flag = 4;
68.                                break;
69.                         case 5:
70.                                if(s->data.x + s->data.y > B)
71.                                {
72.                                       nd[num].data.x = s->data.x+s->data.y-B;
73.                                       nd[num].data.y = B;
74.                                       nd[num].data.flag = 5;
75.                                }
76.                                else{
77.                                            nd[num].data.x = 0;
78.                                            nd[num].data.y = s->data.x+s->data.y;
79.                                            nd[num].data.flag = 5;
80.                                }
81.                                break;
82.                         case 6:
83.                                if(s->data.x+s->data.y > A)
84.                                {
85.                                        nd[num].data.x = A;
86.                                        nd[num].data.y = s->data.x+s->data.y-A;
87.                                        nd[num].data.flag = 6;
88.                                }
89.                                else{
90.                                           nd[num].data.x = s->data.x+s->data.y;
91.                                            nd[num].data.y = 0;
92.                                            nd[num].data.flag = 6;
93.                                }
94.                                break;
95.                   }
96.                  nd[num].data.step = s->data.step+1;
97.                   if(!visit[nd[num].data.x][nd[num].data.y])
98.                   {
99.                            visit[nd[num].data.x][nd[num].data.y] = true;
100.                            nd[num].pre = s;
101.                            if(nd[num].data.x == C || nd[num].data.y == C)
102.                            {
103.                                   Node *p = &nd[num];
104.                                   while(p)
105.                                   {
106.                                         T.push(p->data.flag);
107.                                         p = p->pre;
108.                                   }
109.                                   return nd[num].data.step;
110.                            }
111.                            else an[tail++] = &nd[num++];
112.                   }
113.             }
114.       }
115.       printf("impossible/n");
116. }
117. void input()
118. {
119.       cin>>A>>B>>C;
120.       for(int i=0;i<=A;++i)
121.       for(int j=0;j<=B;++j)
122.       visit[i][j] = false;
123.       if(C == 0) cout<<"0"<<endl;
124.       else
125.       cout<<bfs(0,0)<<endl;
126.       int tag;
127.       while(!T.empty())
128.       {
129.              tag = T.top();
130.              T.pop();
131.              switch(tag)
132.              {
133.                    case 0:break;
134.                    case 1:cout<<"FILL(1)"<<endl;
135.                           break;
136.                    case 2:cout<<"FILL(2)"<<endl;
137.                           break;
138.                    case 3:cout<<"DROP(1)"<<endl;
139.                           break;
140.                    case 4:cout<<"DROP(2)"<<endl;
141.                           break;
142.                    case 5:cout<<"POUR(1,2)"<<endl;
143.                           break;
144.                    case 6:cout<<"POUR(2,1)"<<endl;
145.                           break;
146.              }
147.       }
148. }
149. int main()
150. {
151.       input();
152.       return 0;
153. }