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 倒

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

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

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<queue>
#include<string.h>
#include<iostream>
using namespace std;
#define maxn 110

struct Node
{
int m;//M瓶子中装的可乐数m
int    n;
int s;
int k;//总共倒的次数
};
int M, N, S;
int BFS(Node P);
bool vis[maxn][maxn][maxn];//标记此情况是否有过, 防止重复
int main()
{
Node P;
while(scanf("%d%d%d",&S,&M,&N),M+N+S)
{
int t;
if(M < N)//将M存为最大的
t = M, M = N, N = t;
memset(vis,0,sizeof(vis));
P.s = S, P.m = P.n = P.k = 0;
int ans = -1;
if(S%2 == 0)//奇数是没法平分的
ans = BFS(P);

if(ans == -1)
printf("NO\n");
else
printf("%d\n",ans);
}
return 0;
}

int BFS(Node P)
{
queue<Node> Q;
Q.push(P);
int x;
while( !Q.empty() )
{
Node Pn;
Pn = Q.front();
Q.pop();

if(Pn.s == S/2 && Pn.m == S/2  )//当两个瓶子都是S/2则满足
return Pn.k;

P.k = Pn.k + 1;
/*下面就是倒可乐的过程*/
if(Pn.s < S)
{
x = S - Pn.s;

if(Pn.n > x && !vis[S][Pn.n-x][Pn.m])
{
vis[S][Pn.n-x][Pn.m] = 1;
P.s = S, P.m = Pn.m, P.n = Pn.n-x;
Q.push(P);
}
else if(Pn.n <= x && !vis[Pn.s+Pn.n][0][Pn.m])
{
vis[Pn.s+Pn.n][0][Pn.m] = 1;
P.s = Pn.s + Pn.n, P.m = Pn.m, P.n = 0;
Q.push(P);
}

if(Pn.m > x && !vis[S][Pn.n][Pn.m-x])
{
vis[S][Pn.n][Pn.m-x] = 1;
P.s = S, P.n = Pn.n, P.m = Pn.m-x;
Q.push(P);
}
else if(Pn.m <= x && !vis[Pn.s+Pn.m][Pn.n][0])
{
vis[Pn.s+Pn.m][Pn.n][0] = 1;
P.s = Pn.s+Pn.m, P.n = Pn.n, P.m = 0;
Q.push(P);
}
}

if(Pn.n < N)
{
x = N - Pn.n;

if(Pn.s > x && !vis[Pn.s-x]
[Pn.m])
{
vis[Pn.s-x]
[Pn.m] = 1;
P.s = Pn.s-x, P.n = N, P.m = Pn.m;
Q.push(P);
}
else if(Pn.s <= x && !vis[0][Pn.n+Pn.s][Pn.m])
{
vis[0][Pn.n+Pn.s][Pn.m] = 1;
P.s = 0, P.n = Pn.n+Pn.s, P.m = Pn.m;
Q.push(P);
}

if(Pn.m > x && !vis[Pn.s]
[Pn.m-x])
{
vis[Pn.s]
[Pn.m-x] = 1;
P.s = Pn.s, P.n = N, P.m = Pn.m-x;
Q.push(P);
}
else if(Pn.m <= x && !vis[Pn.s][Pn.n+Pn.m][0])
{
vis[Pn.s][Pn.n+Pn.m][0] = 1;
P.s = Pn.s, P.n = Pn.n+Pn.m, P.m = 0;
Q.push(P);
}
}

if(Pn.m < M)
{
x = M - Pn.m;

if(Pn.s > x && !vis[Pn.s-x][Pn.n][M])
{
vis[Pn.s-x][Pn.n][M] = 1;
P.s = Pn.s-x, P.n = Pn.n, P.m = M;
Q.push(P);
}
else if(Pn.s <= x && !vis[0][Pn.n][Pn.m+Pn.s])
{
vis[0][Pn.n][Pn.m+Pn.s] = 1;
P.s = 0, P.n = Pn.n, P.m = Pn.m+Pn.s;
Q.push(P);
}

if(Pn.n > x && !vis[Pn.s][Pn.n-x][M])
{
vis[Pn.s][Pn.n-x][M] = 1;
P.s = Pn.s, P.n = Pn.n-x, P.m = M;
Q.push(P);
}
else if(Pn.n <= x && !vis[Pn.s][0][Pn.m+Pn.n])
{
vis[Pn.s][0][Pn.m+Pn.n] = 1;
P.s = Pn.s-x, P.n =0, P.m = Pn.m+Pn.n;
Q.push(P);
}
}
}
return -1;
}