HDU1495 非常可乐 BFS||数论

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

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

也就是给出三个杯子，最后的状态是其中两个杯子中水一样多，且为总量的一半，求最少倒水次数。

首先奇数肯定不能平分，因为没有刻度

模拟倒水n-m,n-s;m-n,m-s;s-n,s-m;分满与不满两种情况倒水

#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没有满
            // s -> n
            // 可以倒满
            if(st.s > tn - st.n){
                ed.s = st.s - (tn - st.n);//剩下的s
                ed.n = tn;//相当于把n那个杯子倒满了;
                ed.m = st.m;
                ed.step = st.step + 1;
            }
            // 不能倒满
            else{
                ed.s = 0;//清空了s瓶中的
                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;
}

数论也可以，且十分简便，但还没有理解

#include<bits/stdc++.h>
using namespace std;

int main(){
    int s,n,m;
    while(cin>>s>>n>>m,s+n+m){
        s/=__gcd(n,m);
        if(s&1)//奇数
            cout<<"NO\n";
        else cout<<s-1<<endl;
    }
    return 0;
}