HDU 1495--非常可乐【BFS】

非常可乐

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7960    Accepted Submission(s): 3178

Problem Description

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是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
  
  

 

解析：

三个杯子分别是S ， N， M

分六种情况：

(一）S--》N   | |  M 

（1）S -》N

（a）可以把N倒满 

（b）不能把N倒满

（2）S-》M

（a）可以把M倒满 

（b）不能把M倒满

(二）N--》S   | |  M

（3）N-》S 

（a）可以把S倒满 

（b）不能把S倒满

（4）N-》M

（a）可以把M倒满 

（b）不能把M倒满

(三）M--》S   | |  N 。。。。

分清楚几种情况没，BFS一下即可

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
int ts, tn, tm;
int vis[101][101][101];

struct node {
    int s, n, m, step;
};

void bfs(int ts, int tn, int tm){
    memset(vis, 0 ,sizeof(vis));
    queue<node>q;
    node st, ed;
    st.s = ts;
    st.n = 0;
    st.m = 0;
    st.step = 0;
    q.push(st);
    while(!q.empty()){
        st = q.front();
        q.pop();
        vis[st.s][st.n][st.m] = 1;
        if((st.s == ts/2 && st.n == ts/2)||(st.s == ts/2 && st.m == ts/2)||(st.n == ts/2 && st.m == ts/2)){
            printf("%d\n", st.step);
            return;
        }
        // s -> n || s -> m
        if(st.s){
            // s -> n
            // 可以倒满
            if(st.s > tn - st.n){
                ed.s = st.s - (tn - st.n);
                ed.n = tn;
                ed.m = st.m;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.s = 0;
                ed.n = st.n + st.s;
                ed.m = st.m;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
            //s - >m
            // 可以倒满
            if(st.s > tm - st.m){
                ed.s = st.s - (tm - st.m);
                ed.m = tm;
                ed.n = st.n;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.s = 0;
                ed.m = st.m + st.s;
                ed.n = st.n;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
        }
        // n -> s || n -> m
        if(st.n){
            // n -> s
            // 可以倒满
            if(st.n > ts - st.s){
                ed.n = st.n - (ts - st.s);
                ed.s = ts;
                ed.m = st.m;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.n = 0;
                ed.s = st.s + st.n;
                ed.m = st.m;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
            //n - >m
            // 可以倒满
            if(st.n > tm - st.m){
                ed.n = st.n - (tm - st.m);
                ed.m = tm;
                ed.s = st.s;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.n = 0;
                ed.m = st.n + st.m;
                ed.s = st.s;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
        }
        // m -> s || m -> n
        if(st.m){
            //m -> s
            // 可以倒满
            if(st.m > ts - st.s){
                ed.m = st.m - (ts - st.s);
                ed.s = ts;
                ed.n = st.n;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.m = 0;
                ed.s = st.s + st.m;
                ed.n = st.n;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
            //m -> n
            // 可以倒满
            if(st.m > tn - st.n){
                ed.m = st.m - (tn - st.n);
                ed.n = tn;
                ed.s = st.s;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.m = 0;
                ed.n = st.n + st.m;
                ed.s = st.s;
                ed.step = st.step + 1;
            }
            if(!vis[ed.s][ed.n][ed.m]){
                vis[ed.s][ed.n][ed.m] = 1;
                q.push(ed);
            }
        }
    }
    printf("NO\n");
        return ;
}

int main()
{
    while(scanf("%d%d%d", &ts, &tn, &tm), ts || tn || tm){
        if(ts & 1)
            printf("NO\n");
        else
            bfs(ts, tn, tm);
    }
    return 0;
}