hdu 非常可乐（BFS）（模拟）

非常可乐

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
   
   

 

思路：

直接数组模拟倒水即可。

代码：

#include<stdio.h>
#include<string.h>
int s,n,m;
int vis[102][102][102];//记录状态
struct node
{
    int x,y,z;
    int step;
} w[100010];
int bfs()
{
    int head=0,tail=1;
    w[0].x=s,w[0].y=0,w[0].z=0,w[0].step=0;
    vis[s][0][0]=1;
    while(head<tail)
    {
        node now=w[head];
        int a=now.x,b=now.y,c=now.z;
        if((a==s/2&&b==s/2)||(b==s/2&&c==s/2)||(a==s/2&&c==s/2))
            return now.step;
        if(a)//若a瓶中有水
        {
            if(a>(n-b)&&!vis[a-n+b][n][c])//将a向b倒
            {
                vis[a-n+b][n][c]=1;
                w[tail].x=a-n+b;
                w[tail].y=n;
                w[tail].z=c;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(a<=(n-b)&&!vis[0][a+b][c])
            {
                vis[0][a+b][c]=1;
                w[tail].x=0;
                w[tail].y=a+b;
                w[tail].z=c;
                w[tail].step=now.step+1;
                tail++;
            }
            if(a>(m-c)&&!vis[a-m+c][b][m])//a向c倒
            {
                vis[a-m+c][b][m]=1;
                w[tail].x=a-m+c;
                w[tail].y=b;
                w[tail].z=m;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(a<=(m-c)&&!vis[0][b][a+c])
            {
                vis[0][b][a+c]=1;
                w[tail].x=0;
                w[tail].y=b;
                w[tail].z=a+c;
                w[tail].step=now.step+1;
                tail++;
            }
        }
        if(b)//若b中有水
        {
            if(b>(s-a)&&!vis[s][b-s+a][c])//将b向a倒
            {
                vis[s][b-s+a][c]=1;
                w[tail].x=s;
                w[tail].y=b-s+a;
                w[tail].z=c;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(b<=(s-a)&&!vis[a+b][0][c])
            {
                vis[a+b][0][c]=1;
                w[tail].x=a+b;
                w[tail].y=0;
                w[tail].z=c;
                w[tail].step=now.step+1;
                tail++;
            }
            if(b>(m-c)&&!vis[a][b-m+c][m])//将b向c倒
            {
                vis[a][b-m+c][m]=1;
                w[tail].x=a;
                w[tail].y=b-m+c;
                w[tail].z=m;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(b<=(m-c)&&!vis[a][0][b+c])
            {
                vis[a][0][b+c]=1;
                w[tail].x=a;
                w[tail].y=0;
                w[tail].z=b+c;
                w[tail].step=now.step+1;
                tail++;
            }
        }
        if(c)//若c中有水
        {
            if(c>(s-a)&&!vis[s][b][c-s+a])//将c向a倒
            {
                vis[s][b][c-s+a]=1;
                w[tail].x=s;
                w[tail].y=b;
                w[tail].z=c-s+a;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(c<=(s-a)&&!vis[a+c][b][0])
            {
                vis[a+c][b][0]=1;
                w[tail].x=a+c;
                w[tail].y=b;
                w[tail].z=0;
                w[tail].step=now.step+1;
                tail++;
            }
            if(c>(n-b)&&!vis[a][n][c-n+b])//将c向b倒
            {
                vis[a][n][c-n+b]=1;
                w[tail].x=a;
                w[tail].y=n;
                w[tail].z=c-n+b;
                w[tail].step=now.step+1;
                tail++;
            }
            else if(c<=(n-b)&&!vis[a][b+c][0])
            {
                vis[a][b+c][0]=1;
                w[tail].x=a;
                w[tail].y=b+c;
                w[tail].z=0;
                w[tail].step=now.step+1;
                tail++;
            }
        }
        head++;
    }
    return -1;
}
int main()
{
    while(~scanf("%d%d%d",&s,&n,&m),s+n+m)
    {
        memset(vis,0,sizeof(vis));
        if(s&1)
            printf("NO\n");
        else
        {
            int ans=bfs();
            if(ans==-1)
                printf("NO\n");
            else
                printf("%d\n",ans);
        }
    }
    return 0;
}

ps：时间有点慢，，所以我又百度了一下，找到了一种数学方法

参考博客： http://blog.csdn.net/v5zsq/article/details/52097459

思路：

设两个小瓶子容积分别为a,b，问题转化成通过两个小瓶子的若干次倒进或倒出操作得到(a+b)/2体积的可乐，设两个小瓶子被倒进或倒出x次和y次（这里的x和y是累加后的操作，即x=第一个瓶子倒出的次数-倒进的次数，y=第二个瓶子倒出的次数-倒进的次数），那么问题转化成：

 

所以|x+|y|的最小值为(c+d)/2，通过x和y的通解形式显然可以看出x和y一正一负，不妨设x<0，那么就是往第一个小瓶子倒进x次，第二个小瓶子倒出y次，但是由于瓶子容积有限，所以倒进倒出操作都是通过大瓶子来解决的，一次倒进操作后为了继续使用小瓶子还要将小瓶子中可乐倒回大瓶子中，倒出操作同理，所以总操作次数是(c+d)/2*2=c+d，但是注意最后剩下的(a+b)/2体积的可乐一定是放在两个小瓶子中较大的那个中，而不是再倒回到大瓶子中，所以操作数要减一，答案就是c+d-1 

代码：

#include<stdio.h>
int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}
int main()
{
    int s,n,m;
    while(~scanf("%d%d%d",&s,&n,&m),s+n+m)
    {
        s/=gcd(n,m);
        if(s&1)
            printf("NO\n");
        else
            printf("%d\n",s-1);
    }
    return 0;
}