HDU 1495 非常可乐 BFS 搜索

http://acm.hdu.edu.cn/showproblem.php?pid=1495

题目就不说了， 说说思路！

倒可乐 无非有6种情况:

1. S 向 M 倒

2. S 向 N 倒

3. N 向 M 倒

4. N 向 S 倒

5. M 向 S 倒

6. M 向 N 倒

根据上述的六种情况来进行模拟， 每次模拟的结果都放进队列里面。

注意： 还要用到标记数组，防止数据重复进入队列导致爆栈。

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<math.h>
  4 #include<queue>
  5 #include<string.h>
  6 #include<iostream>
  7 using namespace std;
  8 #define maxn 110
  9
 10 struct Node
 11 {
 12     int m;//M瓶子中装的可乐数m
 13     int    n;
 14     int s;
 15     int k;//总共倒的次数
 16 };
 17 int M, N, S;
 18 int BFS(Node P);
 19 bool vis[maxn][maxn][maxn];//标记此情况是否有过, 防止重复
 20 int main()
 21 {
 22     Node P;
 23     while(scanf("%d%d%d",&S,&M,&N),M+N+S)
 24     {
 25         int t;
 26         if(M < N)//将M存为最大的
 27             t = M, M = N, N = t;
 28         memset(vis,0,sizeof(vis));
 29         P.s = S, P.m = P.n = P.k = 0;
 30         int ans = -1;
 31         if(S%2 == 0)//奇数是没法平分的
 32             ans = BFS(P);
 33
 34         if(ans == -1)
 35             printf("NO\n");
 36         else
 37             printf("%d\n",ans);
 38     }
 39     return 0;
 40 }
 41
 42 int BFS(Node P)
 43 {
 44     queue<Node> Q;
 45     Q.push(P);
 46     int x;
 47     while( !Q.empty() )
 48     {
 49         Node Pn;
 50         Pn = Q.front();
 51         Q.pop();
 52
 53         if(Pn.s == S/2 && Pn.m == S/2  )//当两个瓶子都是S/2则满足
 54             return Pn.k;
 55
 56         P.k = Pn.k + 1;
 57         /*下面就是倒可乐的过程*/
 58         if(Pn.s < S)
 59         {
 60             x = S - Pn.s;
 61
 62             if(Pn.n > x && !vis[S][Pn.n-x][Pn.m])
 63             {
 64                 vis[S][Pn.n-x][Pn.m] = 1;
 65                 P.s = S, P.m = Pn.m, P.n = Pn.n-x;
 66                 Q.push(P);
 67             }
 68             else if(Pn.n <= x && !vis[Pn.s+Pn.n][0][Pn.m])
 69             {
 70                 vis[Pn.s+Pn.n][0][Pn.m] = 1;
 71                 P.s = Pn.s + Pn.n, P.m = Pn.m, P.n = 0;
 72                 Q.push(P);
 73             }
 74
 75             if(Pn.m > x && !vis[S][Pn.n][Pn.m-x])
 76             {
 77                 vis[S][Pn.n][Pn.m-x] = 1;
 78                 P.s = S, P.n = Pn.n, P.m = Pn.m-x;
 79                 Q.push(P);
 80             }
 81             else if(Pn.m <= x && !vis[Pn.s+Pn.m][Pn.n][0])
 82             {
 83                 vis[Pn.s+Pn.m][Pn.n][0] = 1;
 84                 P.s = Pn.s+Pn.m, P.n = Pn.n, P.m = 0;
 85                 Q.push(P);
 86             }
 87         }
 88
 89         if(Pn.n < N)
 90         {
 91             x = N - Pn.n;
 92
 93             if(Pn.s > x && !vis[Pn.s-x][N][Pn.m])
 94             {
 95                 vis[Pn.s-x][N][Pn.m] = 1;
 96                 P.s = Pn.s-x, P.n = N, P.m = Pn.m;
 97                 Q.push(P);
 98             }
 99             else if(Pn.s <= x && !vis[0][Pn.n+Pn.s][Pn.m])
100             {
101                 vis[0][Pn.n+Pn.s][Pn.m] = 1;
102                 P.s = 0, P.n = Pn.n+Pn.s, P.m = Pn.m;
103                 Q.push(P);
104             }
105
106             if(Pn.m > x && !vis[Pn.s][N][Pn.m-x])
107             {
108                 vis[Pn.s][N][Pn.m-x] = 1;
109                 P.s = Pn.s, P.n = N, P.m = Pn.m-x;
110                 Q.push(P);
111             }
112             else if(Pn.m <= x && !vis[Pn.s][Pn.n+Pn.m][0])
113             {
114                 vis[Pn.s][Pn.n+Pn.m][0] = 1;
115                 P.s = Pn.s, P.n = Pn.n+Pn.m, P.m = 0;
116                 Q.push(P);
117             }
118         }
119
120         if(Pn.m < M)
121         {
122             x = M - Pn.m;
123
124             if(Pn.s > x && !vis[Pn.s-x][Pn.n][M])
125             {
126                 vis[Pn.s-x][Pn.n][M] = 1;
127                 P.s = Pn.s-x, P.n = Pn.n, P.m = M;
128                 Q.push(P);
129             }
130             else if(Pn.s <= x && !vis[0][Pn.n][Pn.m+Pn.s])
131             {
132                 vis[0][Pn.n][Pn.m+Pn.s] = 1;
133                 P.s = 0, P.n = Pn.n, P.m = Pn.m+Pn.s;
134                 Q.push(P);
135             }
136
137             if(Pn.n > x && !vis[Pn.s][Pn.n-x][M])
138             {
139                 vis[Pn.s][Pn.n-x][M] = 1;
140                 P.s = Pn.s, P.n = Pn.n-x, P.m = M;
141                 Q.push(P);
142             }
143             else if(Pn.n <= x && !vis[Pn.s][0][Pn.m+Pn.n])
144             {
145                 vis[Pn.s][0][Pn.m+Pn.n] = 1;
146                 P.s = Pn.s-x, P.n =0, P.m = Pn.m+Pn.n;
147                 Q.push(P);
148             }
149         }
150     }
151     return -1;
152 }