M - 非常可乐

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

抽象的搜索问题，

每次操作都有6个方向 （将三个杯子分别编号为0 ，1，2对应的Full的容量为S,N,M）

1.     0->1(0号杯子往1号杯子里面倒)

2.     2->1

3.     0->2

4.     1->2

5      1->0

6      2->0

将每次操作后杯子饮料的容量作为地图map[][]存放前两个杯子饮料的容量 。（三个杯子饮料总和一定，前两个确定，第三个也杯子内饮料的容量也就确定了，所以用两个杯子就可以了）

这样根据杯子倒水次数来广搜，杯子的饮料的容量作为路径去搜索

1.方向数组vis[6][3] 存每次操作对应的编号

2.Full[]数组存下对应编号杯子的最大容量

3.tiji[]数组表示此次倒水之后对应编号的饮料的容量

4.map[][]数组以前两个编号杯子的容量为下标，0表示出现过，1表示未出现过;

5.用个Turn（）函数来表示倒饮料的操作

map[i][j]=1，表示该状态已经存在，下次再出现i ,j的情况时就不用去搜索这种情况(未找到答案也是这因这种情况而停止的)

PS值得一提的是，没有答案时说明倒水操作一直在一个重复过的循环当中,//题外话，不要将这个看作解题的一部分(●'◡'●)

#include<stdio.h>开三位数组会超时，但这道题开个二维数组就OK了，因为总量一定 前两个的体积知道 第三个也就确定了
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stdlib.h>
#define N 110
#include<string>
using namespace std;
int map[N][N],flag,s,n,m,ans,vis[6][3]={{1,0,0},{2,0,0},{0,1,1},{2,1,1},{0,2,2},{1,2,2}},Full[3],tiji[3];
double zhi;
struct node{
int v,a,b,step;
};
queue<struct node>mmp;
void turn(int *aa,int *bb,int full)//a->b
{
     int a,b;
     a=*aa;
     b=*bb;
     if(*aa+*bb>full)
     {
         a=*aa+*bb-full;
         b=full;
     }
     else
     {
         a=0;
         b=*aa+*bb;
     }
     *aa=a;
     *bb=b;
     return ;
}

void dfs()
{
    struct node mm;
    int ss,mod1,vv,aa,bb;//表示此时的状态 vv,aa,bb;
    mm=mmp.front();
    vv=mm.v;
    aa=mm.a;
    bb=mm.b;
    ss=mm.step;
    mod1=0;
    if(aa==zhi)
        mod1++;
    if(bb==zhi)
        mod1++;
    if(vv==zhi)
        mod1++;
    if(mod1==2)//是否为答案
    {
        flag=1;
        ans=ss;
        return;
    }
    mmp.pop();
    for(int i=0;i<6;i++)
    {
        tiji[0]=vv;//每次都初始化体积数组
        tiji[1]=aa;//
        tiji[2]=bb;//
        turn(&tiji[vis[i][0]],&tiji[vis[i][1]],Full[vis[i][2]]);//倒水操作
        if(!map[tiji[0]][tiji[1]])//用不用去搜索
        {
            struct node mm;
            mm.v=tiji[0];
            mm.a=tiji[1];
            mm.b=tiji[2];
            mm.step=ss+1;
            map[tiji[0]][tiji[1]]=1;
            mmp.push(mm);
        }
    }

}
void bfs()
{
    struct node qq;
    qq.v=s;
    qq.a=qq.b=qq.step=0;
    map[s][0]=1;
    mmp.push(qq);
    while(!mmp.empty())
    {
        dfs();
        if(flag)
            return;
    }
}
int main()
{
    while(scanf("%d %d %d",&s,&n,&m)&&s)
    {
        Full[0]=s;
        Full[1]=n;
        Full[2]=m;
        flag=0;
        zhi=s/2.0;
        memset(map,0,sizeof(map));
        while(!mmp.empty())
            mmp.pop();
        bfs();
        if(flag)
            printf("%d\n",ans);
        else
            printf("NO\n");
    }
}

转载于:https://www.cnblogs.com/dchnzlh/p/9780088.html