HDU 1495 非常可乐

非常可乐

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


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
 




一看是倒水的问题,毫无疑问用BFS,但是需要注意的是这个题不是分出来二分之一的总量就完事了,还要再凑出来一个二分之一的总量,这个就比较简单了,那就是在步数上加1就好。 

然而代码太丑了。写的超级麻烦。以后绝对不这么写了。

/*************************************************************************
	> File Name: 非常可乐.cpp
	> Author: Zhanghaoran0
	> Mail: chiluamnxi@gmail.com
	> Created Time: 2015年08月18日 星期二 08时27分37秒
 ************************************************************************/

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>

using namespace std;
/*
int S, N, M;
bool flag[105][105];
int Max = 1000001;
bool dfs(int x, int y, int z, int step){
    if(x == S / 2 || y == S / 2 || z == S / 2){
        Max = min(Max, step + 1); 
	return true;
    }
    if(!flag[N][y]){
        flag[N][y] = true;
        dfs(N, y, z - x, step + 1);
        flag[N][y] = false;
    }
    if(!flag[x][M]){
        flag[x][M] = true;
        dfs(x, M, z - y, step + 1);
        flag[x][M] = false;
    }
    
    if(x != 0 || y != 0){
        if(x + y > N){
            if(!flag[N][y - (N - x)]){
                flag[N][y - (N - x)] = true;
                dfs(N, y - (N - x), z, step + 1);
                flag[N][y - (N - x)] = false;
            }
        }
        else if(x + y <= N){
            if(!flag[x + y][0]){
                flag[x + y][0] = true;
                dfs(x + y, 0, z, step + 1);
                flag[x + y][0] = false;
            }
        }
        if(x + y > M){
            if(!flag[x - (M - y)][M]){
                flag[x - (M - y)][M] = true;
                dfs(x - (M - y), M, z, step + 1);
                flag[x - (M - y)][M] = false;
            }
            
        }
        else if(x + y <= M){
            if(!flag[0][x + y]){
                flag[0][x + y] = true;
                dfs(0, x + y, z, step + 1);
                flag[0][x + y] = false;
            }
        }

        if(!flag[0][y]){
            flag[0][y] = true;
            dfs(0, y, z + x, step + 1);
            flag[0][y] = false;
        }

        if(!flag[x][0]){
            flag[x][0] = true;
            dfs(x, 0, y + z, step + 1);
            flag[x][0] = false;
        }
    }
}


int main(void){
    while(1){
        cin >> S >> N >> M;
        if(S == 0 && N == 0 && M == 0)
            break;
        if(S % 2){ 
            cout << "NO" << endl;
            continue;
        }
        
        memset(flag, 0, sizeof(flag));

        dfs(0, 0, S, 0);
        if(Max != 1000001)
            cout << Max << endl;
        else
            cout << "NO" << endl;
        Max = 1000001;
    }
    return 0;
}
*/



bool flag[105][105];
int S, N, M;
int goal;
struct node{
    int nowpos[3];
    int step;
}q[1000001];
int ans;


int  bfs(){
    int head = 0;
    int tail = 1;
    q[0].nowpos[0] = S;
    q[0].nowpos[1] = 0;
    q[0].nowpos[2] = 0;
    q[0].step = 0;
    flag[0][0] = true;

    while(head < tail){
        int num = 0;
        if(q[head].nowpos[0] == goal)
            num ++;
        if(q[head].nowpos[1] == goal)
            num ++;
        if(q[head].nowpos[2] == goal)
            num ++;
        if(num == 2)
            return q[head].step;

        if(q[head].nowpos[0] != 0){
            if(q[head].nowpos[0] > N - q[head].nowpos[1]){
                q[tail].nowpos[0] = q[head].nowpos[0] - (N - q[head].nowpos[1]);
                q[tail].nowpos[1] = N;
                q[tail].nowpos[2] = q[head].nowpos[2];
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[0] = 0;
                q[tail].nowpos[1] = q[head].nowpos[1] + q[head].nowpos[0];
                q[tail].nowpos[2] = q[head].nowpos[2];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }

            if(q[head].nowpos[0] > M - q[head].nowpos[2]){
                q[tail].nowpos[0] = q[head].nowpos[0] - (M - q[head].nowpos[2]);
                q[tail].nowpos[1] = q[head].nowpos[1];
                q[tail].nowpos[2] = M;
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[0] = 0;
                q[tail].nowpos[2] = q[head].nowpos[2] + q[head].nowpos[0];
                q[tail].nowpos[1] = q[head].nowpos[1];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }
        }



        if(q[head].nowpos[1] != 0){
            if(q[head].nowpos[1] > S - q[head].nowpos[0]){
                q[tail].nowpos[0] = S;
                q[tail].nowpos[1] = q[head].nowpos[1] - S + q[head].nowpos[0];
                q[tail].nowpos[2] = q[head].nowpos[2];
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[1] = 0;
                q[tail].nowpos[0] = q[head].nowpos[1] + q[head].nowpos[0];
                q[tail].nowpos[2] = q[head].nowpos[2];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }

            if(q[head].nowpos[1] > M - q[head].nowpos[2]){
                q[tail].nowpos[1] = q[head].nowpos[1] - (M - q[head].nowpos[2]);
                q[tail].nowpos[0] = q[head].nowpos[0];
                q[tail].nowpos[2] = M;
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[1] = 0;
                q[tail].nowpos[2] = q[head].nowpos[2] + q[head].nowpos[1];
                q[tail].nowpos[0] = q[head].nowpos[0];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }
        }

	    if(q[head].nowpos[2] != 0){
            if(q[head].nowpos[2] > S - q[head].nowpos[0]){
                q[tail].nowpos[0] = S;
                q[tail].nowpos[2] = q[head].nowpos[2] - S + q[head].nowpos[0];
                q[tail].nowpos[1] = q[head].nowpos[1];
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[2] = 0;
                q[tail].nowpos[0] = q[head].nowpos[2] + q[head].nowpos[0];
                q[tail].nowpos[1] = q[head].nowpos[1];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }

            if(q[head].nowpos[2] > N - q[head].nowpos[1]){
                q[tail].nowpos[2] = q[head].nowpos[2] - (N - q[head].nowpos[1]);
                q[tail].nowpos[0] = q[head].nowpos[0];
                q[tail].nowpos[1] = N;
                q[tail].step = q[head].step + 1;
            }
            else{
                q[tail].nowpos[2] = 0;
                q[tail].nowpos[1] = q[head].nowpos[2] + q[head].nowpos[1];
                q[tail].nowpos[0] = q[head].nowpos[0];
                q[tail].step = q[head].step + 1;
            }

            if(!flag[q[tail].nowpos[1]][q[tail].nowpos[2]]){
                flag[q[tail].nowpos[1]][q[tail].nowpos[2]] = true;
                tail ++;
            }
        }
        head ++;
    }
    return -1;
}



int main(void){
    while(1){
        cin >> S >> N >> M;
        if(S == 0 && N == 0 && M == 0)
            break;
        if(S % 2){
            cout << "NO" << endl;
            continue;
        }
        
        goal = S / 2;
        memset(flag, 0, sizeof(flag));
        ans = bfs();
        if(ans == -1)
            cout << "NO" << endl;
        else 
            cout << ans << endl;
    }
    return 0;
}


  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值