非常可乐

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，阿牛就要求和seeyou一起分享这一瓶可乐，而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子，它们的容量分别是N 毫升和M 毫升 可乐的体积为S （S<101）毫升　(正好装满一瓶) ，它们三个之间可以相互倒可乐 (都是没有刻度的，且 S==N+M，101＞S＞0，N＞0，M＞0) 。聪明的ACMER你们说他们能平分吗？如果能请输出倒可乐的最少的次数，如果不能输出"NO"。

 

Input

三个整数 : S 可乐的体积 , N 和 M是两个杯子的容量，以"0 0 0"结束。

 

Output

如果能平分的话请输出最少要倒的次数，否则输出"NO"。

 

Sample Input

  
  

   
   7 4 3
4 1 3
0 0 0
  
  

 

Sample Output

  
  

   
   NO
3
  
  

 

读完题目我是懵的，，想不到怎么搜索，昨晚问了下学长，然后他用了大概两个小时敲完AC了（膜一番，学长说，BFS呗，加上if判断就行了，嗯，，我说好吧，，并没有给我看代码，，然后我就直接放弃了，，今天上午来到后，突然想敲着试一下，发现也不是没有思路，交了几发，都是超时，后来在网上找了一下，在if判断那里，只有当一个杯子不是满的时候才执行if（往里加可乐，改完就AC了，所以一共六种情况，直接上代码吧

#include <iostream>  
#include <algorithm> 
#include <cstring> 
#include <cstdio>  
#include <queue>  
  
using namespace std;  
const int N = 100;
  
struct node
{
    int a, b, c, step;      //a,b,c分别代表三个杯子里的可乐,step是操作次数
};
int s, n, m;
bool vis[N][N][N];          //标记数组，记录当前的状态是否处理过

int BFS()
{
    queue<node> q;
    struct node t, u;
    memset(vis, 0, sizeof(vis));
    t.a = s;
    t.b = 0;
    t.c = 0;
    t.step = 0;
    q.push(t);
    vis[s][n][m] = 1;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        if((u.a == 0 && u.b == u.c)||(u.b == 0 && u.a == u.c)||(u.c == 0 && u.a == u.b))
            return u.step; 
        int p;  //p是倒的可乐的体积
        if(u.a && u.b != n)     //a杯有可乐，b杯不满，a往b中倒
        {
            p = min(u.a, n-u.b);  
            t.a = u.a - p;
            t.b = u.b + p;
            t.c = u.c;
            if(!vis[t.a][t.b][t.b])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
             }
        }
        if(u.a && u.c != m)     //同上，a往c中倒
        {
            p = min(u.a, m-u.c);
            t.a = u.a - p;
            t.b = u.b;
            t.c = u.c + p;
            if(!vis[t.a][t.b][t.b])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
            }
        }
        if(u.b && u.a != s)     //b往a中倒
        {
            p = min(u.b, s-u.a);
            t.a = u.a + p;
            t.b = u.b - p;
            t.c = u.c;
            if(!vis[t.a][t.b][t.c])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
            }
        }
        if(u.b && u.c != m)     //b往c中倒
        {
            p = min(u.b, m-u.c);
            t.a = u.a;
            t.b = u.b - p;
            t.c = u.c + p;
            if(!vis[t.a][t.b][t.c])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
            }
        }
        if(u.c && u.a != s)     //c往a中倒
        {
            p = min(u.c, s-u.a);
            t.a = u.a + p;
            t.b = u.b;
            t.c = u.c - p;
            if(!vis[t.a][t.b][t.c])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
            }
        }
        if(u.c && u.b != n)     //c往b中倒
        {
            p = min(u.c, n-u.b);
            t.a = u.a;
            t.b = u.b + p;
            t.c = u.c - p;
            if(!vis[t.a][t.b][t.c])
            {
                t.step = u.step + 1;
                q.push(t);
                vis[t.a][t.b][t.c] = 1;
            }
        }
    }
    return 0;
}
int main()  
{  
    while(~scanf("%d%d%d", &s, &n, &m))
    {
        if(s == 0 && n == 0 && m == 0)
            break;
        if(s % 2 == 1)          //奇数不可能平分
        {
            printf("NO\n");
            continue;
        }
        int cnt = BFS();
        if(cnt)
            printf("%d\n", cnt);
        else
            printf("NO\n");
    }
    return 0;  
}