非常可乐 HDU - 1495

点击打开链接

三个杯子 就开三维的关系矩阵表示三者之间的关系 通过BFS来遍历关系矩阵

若由三杯水分别为 x1 y1 z1 的状态 经过互相倒水的合法操作后 可以变为 x2 y2 z2 的状态

则e[x1][y1][z1]与e[x2][y2][z2]之间有关系 相当于(x1,y1,z1)与(x2,y2,z2)两点之间联通 继续遍历

直到找到题目所给目标状态为止

虽然BFS写的比较麻烦 但这种方法似乎比较快一些 31ms 看其他人貌似都跑了七八百..

 

#include <stdio.h>

struct node
{
    int x;
    int y;
    int z;
    int l;
};

struct node que[1000001];
int book[101][101][101];
int s,n,m,head,tail;

int bfs();
int judge(int u,int v,int w);
int min(int a,int b);

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

int bfs()
{
    int i,j,k,cx,cy,cz,cl,t;
    for(i=0;i<=s;i++)
    {
        for(j=0;j<=n;j++)
        {
            for(k=0;k<=m;k++)
            {
                book[i][j][k]=0;
            }
        }
    }
    head=1,tail=1;
    que[tail].x=s;
    que[tail].y=0;
    que[tail].z=0;
    que[tail].l=0;
    tail++;
    book[s][0][0]=1;
    while(head<tail)
    {
        cx=que[head].x,cy=que[head].y,cz=que[head].z,cl=que[head].l;

        if(cx>0)
        {
            if(cy<n)
            {
                t=min(cx,n-cy);
                if(book[cx-t][cy+t][cz]==0)
                {
                    que[tail].x=cx-t;
                    que[tail].y=cy+t;
                    que[tail].z=cz;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx-t][cy+t][cz]=1;
                    if(judge(cx-t,cy+t,cz))
                    {
                        return que[tail-1].l;
                    }
                }
            }
            if(cz<m)
            {
                t=min(cx,m-cz);
                if(book[cx-t][cy][cz+t]==0)
                {
                    que[tail].x=cx-t;
                    que[tail].y=cy;
                    que[tail].z=cz+t;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx-t][cy][cz+t]=1;
                    if(judge(cx-t,cy,cz+t))
                    {
                        return que[tail-1].l;
                    }
                }
            }
        }

        if(cy>0)
        {
            if(cx<s)
            {
                t=min(cy,s-cx);
                if(book[cx+t][cy-t][cz]==0)
                {
                    que[tail].x=cx+t;
                    que[tail].y=cy-t;
                    que[tail].z=cz;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx+t][cy-t][cz]=1;
                    if(judge(cx+t,cy-t,cz))
                    {
                        return que[tail-1].l;
                    }
                }
            }
            if(cz<m)
            {
                t=min(cy,m-cz);
                if(book[cx][cy-t][cz+t]==0)
                {
                    que[tail].x=cx;
                    que[tail].y=cy-t;
                    que[tail].z=cz+t;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx][cy-t][cz+t]=1;
                    if(judge(cx,cy-t,cz+t))
                    {
                        return que[tail-1].l;
                    }
                }
            }
        }

        if(cz>0)
        {
            if(cx<s)
            {
                t=min(cz,s-cx);
                if(book[cx+t][cy][cz-t]==0)
                {
                    que[tail].x=cx+t;
                    que[tail].y=cy;
                    que[tail].z=cz-t;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx+t][cy][cz-t]=1;
                    if(judge(cx+t,cy,cz-t))
                    {
                        return que[tail-1].l;
                    }
                }
            }
            if(cy<n)
            {
                t=min(cz,n-cy);
                if(book[cx][cy+t][cz-t]==0)
                {
                    que[tail].x=cx;
                    que[tail].y=cy+t;
                    que[tail].z=cz-t;
                    que[tail].l=cl+1;
                    tail++;
                    book[cx][cy+t][cz-t]=1;
                    if(judge(cx,cy+t,cz-t))
                    {
                        return que[tail-1].l;
                    }
                }
            }
        }

        head++;
    }
    return -1;
}

int judge(int u,int v,int w)
{
    if(u==s/2&&v==s/2&&w==0) return 1;
    if(u==s/2&&v==0&&w==s/2) return 1;
    if(u==0&&v==s/2&&w==s/2) return 1;
    return 0;
}

int min(int a,int b)
{
    if(a>b) return b;
    else return a;
}