hdu1495(非常可乐 dfs）

题目链接
这题题意真让我想到小时候做过的脑筋急转弯，讲的是给你三个杯子，第一个杯子大小是后两个杯子大小之和，且第一个杯子开始是满的，其他两个是空的，问你经过多少次倒来倒去，能够是两个杯子里一样多平分最初可乐总量也就是第一个杯子的大小，不能就输出NO。
开始真的没有思路，联想了一点，如果杯子大小是奇数，肯定就不能倒出来，因为杯子大小都是整数不能倒出0.5出来吧。
后来看了别人题解。。。（果然题做的少，知道也不会用）用bfs,它将每次各个杯子的水量作为一个状态，用结构体保存，加入对队列里，模拟搜索下个状态，知道搜到。

#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
struct node
{
    int s,n,m;
    int step;
};
bool book[110][110][110];
int S,N,M;
void bfs()
{
   queue<node>Q;
   node p,q;
   p.s=S;
   p.n=0;
   p.m=0;
   p.step=0;
   memset(book,false,sizeof(book));
   book[p.s][p.n][p.m]=true;
   Q.push(p);
   while(!Q.empty())
   {
       p=Q.front();
       Q.pop();
       if((p.s==S/2&&p.n==S/2)||(p.s==S/2&&p.m==S/2)||(p.n==S/2&&p.m==S/2))
       {
           printf("%d\n",p.step);
           return;
       }
       if(p.s!=0)
       {
           if(p.s>N-p.n)
           {
               q.s=p.s-(N-p.n);
               q.n=N;
               q.m=p.m;
               q.step=p.step+1;
           }
           else
           {
               q.s=0;
               q.n=p.n+p.s;
               q.m=p.m;
               q.step=p.step+1;
           }
           if(!book[q.s][q.n][q.m])
           {
               book[q.s][q.n][q.m]=true;
               Q.push(q);
           }
           if(p.s>M-p.m)
           {
               q.s=p.s-(M-p.m);
               q.n=p.n;
               q.m=M;
               q.step=p.step+1;
            }
           else
           {
               q.s=0;
               q.n=p.n;
               q.m=p.m+p.s;
               q.step=p.step+1;
           }
             if(!book[q.s][q.n][q.m])
           {
               Q.push(q);
               book[q.s][q.n][q.m]=true;
           }
       }
       if(p.n!=0)
       {
            if(p.n>S-p.s)
           {
               q.s=S;
               q.n=p.n-(S-p.s);
               q.m=p.m;
               q.step=p.step+1;
           }
           else
           {
               q.s=p.n+p.s;
               q.n=0;
               q.m=p.m;
               q.step=p.step+1;
           }
             if(!book[q.s][q.n][q.m])
           {
               Q.push(q);
               book[q.s][q.n][q.m]=true;
           }
           if(p.n>M-p.m)
           {
               q.s=p.s;
               q.n=p.n-(M-p.m);
               q.m=M;
               q.step=p.step+1;
           }
           else
           {
               q.s=p.s;
               q.n=0;
               q.m=p.m+p.n;
               q.step=p.step+1;
           }
             if(!book[q.s][q.n][q.m])
           {
               Q.push(q);
               book[q.s][q.n][q.m]=true;
           }
       }
       if(p.m!=0)
       {
           if(p.m>S-p.s)
           {
               q.s=S;
               q.n=p.n;
               q.m=p.m-(S-p.s);
               q.step=p.step+1;
           }
           else
           {
               q.s=p.s+p.m;
               q.n=p.n;
               q.m=0;
               q.step=p.step+1;
           }
             if(!book[q.s][q.n][q.m])
           {
               Q.push(q);
               book[q.s][q.n][q.m]=true;
           }
           if(p.m>N-p.n)
           {
               q.s=p.s;
               q.n=N;
               q.m=p.m-(N-p.n);
               q.step=p.step+1;
           }
           else
           {
               q.s=p.s;
               q.n=p.n+p.m;
               q.m=0;
               q.step=p.step+1;
           }
             if(!book[q.s][q.n][q.m])
           {
               Q.push(q);
               book[q.s][q.n][q.m]=true;
           }
       }
   }
   printf("NO\n");

}

int main()
{
    while(~scanf("%d %d %d",&S,&N,&M)&&S&&N&&M)
    {
        if(S%2==1)
        {
            printf("NO\n");
        }
        else
        {
            bfs();
        }
    }
    return 0;
}

说实话这段模拟对我提高了代码的功底，是我太菜了吧。

后来又想到也可以用dfs呀，把每个状态放在一起就像图类问题一样吧~！dfs把所有可能的情况都枚举一遍，选倒水最少的那一次。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int S,N,M,s,n,m,book[110][110][110],Min,flag;
void dfs(int s,int n,int m,int dep)
{
    if((s==S/2&&n==S/2)||(s==S/2&&m==S/2)||(n==S/2&&m==S/2))
    {
        if(dep<Min)
        {
            flag=1;
            Min=dep;
        }
        return;
    }
    else
    {
        int t;
        if(s>0&&n<N)
        {
            t=min(s,N-n);
            if(!book[s-t][n+t][m])
            {
              book[s-t][n+t][m]=1;
              dfs(s-t,n+t,m,dep+1);
              book[s-t][n+t][m]=0;
            }
        }
        if(s>0&&m<M)
        {
            t=min(s,M-m);
            if(!book[s-t][n][m+t])
            {
                book[s-t][n][m+t]=1;
                dfs(s-t,n,m+t,dep+1);
                book[s-t][n][m+t]=0;
            }
        }
        if(n>0&&s<S)
        {
            t=min(n,S-s);
            if(!book[s+t][n-t][m])
            {
                book[s+t][n-t][m]=1;
                dfs(s+t,n-t,m,dep+1);
                book[s+t][n-t][m]=0;
            }
        }
        if(n>0&&m<M)
        {
            t=min(n,M-m);
            if(!book[s][n-t][m+t])
            {
                book[s][n-t][m+t]=1;
                dfs(s,n-t,m+t,dep+1);
                book[s][n-t][m+t]=0;
            }
        }
        if(m>0&&s<S)
        {
            t=min(m,S-s);
            if(!book[s+t][n][m-t])
            {
                book[s+t][n][m-t]=1;
                dfs(s+t,n,m-t,dep+1);
                book[s+t][n][m-t]=0;
            }
        }
        if(m>0&&n<N)
        {
            t=min(m,N-n);
            if(!book[s][n+t][m-t])
            {
                book[s][n+t][m-t]=1;
                dfs(s,n+t,m-t,dep+1);
                book[s][n+t][m-t]=0;
            }
        }
    }
    return;
}

int main()
{
    while(~scanf("%d %d %d",&S,&N,&M)&&S&&N&&M)
    {
        Min=999999999;
        if(S%2)
        {
            printf("NO\n");
            continue;
        }
        flag=0;
        memset(book,0,sizeof(book));
        book[S][0][0]=1;
        dfs(S,0,0,0);
        if(flag==1)
            printf("%d\n",Min);
        else
            printf("NO\n");
    }
}