hdu1495 非常可乐(灰常有意思的bfs)

这题代码有150行 但是基本是六中情况的重复了

先说题目 给三个数字 s n m s=n+m s在1到100之间

就是个倒水问题可以从第一个倒向第二个 类似的一共可以有六中到发

现在要求最少经过多少步就能平分那么多水  

首先剪枝是 如果s是奇数必然不行。

一看到要求最少的步数就知道用bfs了

我们用vis标记状态

每个状态有三个整数组成 表示这三个杯子里的可乐数量

然后对每个状态的递推是 6种 也就是3!种。从一个到到另一个 再标记 入队

所以 题目还是蛮简单的

 

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=101;

struct Node
{
    int x,y,z,step;
};

int s,n,m;
bool vis[maxn][maxn][maxn];

int bfs();
inline bool finish();

int main()
{
    int ans;
    while(scanf("%d %d %d",&s,&n,&m),(s+m+n))
    {
        if(s%2==1)
        ans=-1;
        else
        ans=bfs();
        if(ans<0)
            printf("NO\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}

inline bool finish(int a,int b,int c)
{
    if(a==b&&c==0 || a==c&&b==0 || b==c&&a==0)
        return true;
    else
        return false;
}

int bfs()
{
    Node node,tmp;
    int t;
    memset(vis,0,sizeof(vis));
    node.x=s;node.y=0;node.z=0;node.step=0;
    queue<Node> q;

    vis[s][0][0]=1;
    q.push(node);

    while(!q.empty())
    {
        tmp=q.front();
        q.pop();
        //printf("出队列一次 分别为%d %d %d %d\n",tmp.x,tmp.y,tmp.z,tmp.step);
        node.step=tmp.step+1;//如果可以插入队列 那么所有node的step都是tmp的+1 直接提前写了

        if(finish(tmp.x,tmp.y,tmp.z))
            return tmp.step;

        if(tmp.x>0)//第一个杯子还有可乐 不可能存在同时两个杯子都满了 除非得到最终答案
        {
            if(tmp.y<n)//第二个还没满 说明可以从第一个杯子倒向第二个
            {
                t=n-tmp.y;//第二个杯子还差t就满了
                node.x=tmp.x>=t?tmp.x-t:0;
                node.y=tmp.x>=t?n:tmp.y+tmp.x;
                node.z=tmp.z;
                if(!vis[node.x][node.y][node.z])//这种情况下还没有访问过
                {
                    vis[node.x][node.y][node.z]=1;//标记这种情况已访问
                    //printf("进队列！！%d %d %d\n",node.x,node.y,node.z);
                    q.push(node);//这种情况入队列
                }
            }
            if(tmp.z<m)//第三个杯子还没满 说明可以从第一个倒向第三个
            {
                t=m-tmp.z;
                node.x=tmp.x>=t?tmp.x-t:0;
                node.y=tmp.y;
                node.z=tmp.x>=t?m:tmp.x+tmp.z;
                if(!vis[node.x][node.y][node.z])
                {
                    vis[node.x][node.y][node.z]=1;
                    //printf("进队列！！%d %d %d\n",node.x,node.y,node.z);
                    q.push(node);
                }
            }
        }
        if(tmp.y>0)//后面就是代码重复了。。。第二个杯子有可乐 分别向第一个第三个倒可乐
        {
            if(tmp.x<s)//第一个杯子没有满
            {
                t=s-tmp.x;
                node.x=tmp.y>=t?s:tmp.y+tmp.x;
                node.y=tmp.y>=t?tmp.y-t:0;
                node.z=tmp.z;
                if(!vis[node.x][node.y][node.z])
                {
                    vis[node.x][node.y][node.z]=1;
                    q.push(node);
                }
            }
            if(tmp.z<m)//第二个倒向第三个
            {
                t=m-tmp.z;
                node.x=tmp.x;
                node.y=tmp.y>=t?tmp.y-t:0;
                node.z=tmp.y>=t?m:tmp.y+tmp.z;
                if(!vis[node.x][node.y][node.z])
                {
                    vis[node.x][node.y][node.z]=1;
                    q.push(node);
                }
            }
        }
        if(tmp.z>0)//第三个有可乐 从第三个倒向前两个
        {
            if(tmp.x<s)
            {
                t=s-tmp.x;
                node.x=tmp.z>=t? s:tmp.x+tmp.z;
                node.y=tmp.y;
                node.z=tmp.z>=t? tmp.z-t:0;
                if(!vis[node.x][node.y][node.z])
                {
                    vis[node.x][node.y][node.z]=1;
                    q.push(node);
                }
            }
            if(tmp.y<m)
            {
                t=n-tmp.y;
                node.x=tmp.x;
                node.y=tmp.z>=t? n:tmp.y+tmp.z;
                node.z=tmp.z>=t? tmp.z-t:0;
                if(!vis[node.x][node.y][node.z])
                {
                    vis[node.x][node.y][node.z]=1;
                    q.push(node);
                }
            }
        }
    }
    return -1;
}