Pots POJ - 3414【状态转移bfs+回溯】

典型的倒水问题：

即把两个水杯的每种状态视为bfs图中的点，如果两种状态可以转化，即可认为二者之间可以连一条边。

有3种倒水的方法，对应2个杯子，共有6种可能的状态转移方式。即相当于图中想走的方法有6种，依次枚举即可。

用一个二维数组标记状态，以免重复。

难点在于输出路径，即bfs回溯。

我的处理方法是，在bfs的队列基础上，用一个vector保存每一个可能的状态，即每个状态对应一个编号。同时结构体中不仅保存每个状态的信息，而且还要保存每个状态的对应编号和上一个状态的对应编号。

那么，当bfs到达终点后，就可以从后向前进行回溯，找到路径，然后反向输出即可。

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 using namespace std;
 int Va,Vb,C;
 struct pot
 {
     int a,b,step,t,my,last;
 };
 bool vis[][];
 int a[];
 queue<pot>que;
 vector<pot>pre;
 int bfs()
 {
     while(!que.empty())
         que.pop();
     pot s=pot{,,-,,,-};
     que.push(s);
     vis[][]=;
     pre.push_back(s);
     while(!que.empty())
     {
         pot now=que.front();
         que.pop();
         for(int i=;i<;i++)
         {
             pot tmp=now;
             if(i==)//fill(1)
                 tmp.a=Va;
             else if(i==)//fill(2)
                 tmp.b=Vb;
             else if(i==)//drop(1)
                 tmp.a=;
             else if(i==)//drop(2)
                 tmp.b=;
             else if(i==)//pour(1,2)
             {
                 if(tmp.a>Vb-tmp.b)
                 {
                     tmp.a-=(Vb-tmp.b);
                     tmp.b=Vb;
                 }
                 else
                 {
                     tmp.b+=tmp.a;
                     tmp.a=;
                 }
             }
             else if(i==)//pour(2,1)
             {
                 if(tmp.b>Va-tmp.a)
                 {
                     tmp.b-=(Va-tmp.a);
                     tmp.a=Va;
                 }
                 else
                 {
                     tmp.a+=tmp.b;
                     tmp.b=;
                 }
             }
             if(!vis[tmp.a][tmp.b])
             {
                 tmp.step=i;
                 tmp.t=now.t+;
                 tmp.last=now.my;
                 pre.push_back(tmp);
                 tmp.my=pre.size()-;
                 vis[tmp.a][tmp.b]=;
                 que.push(tmp);
                 if(tmp.a==C||tmp.b==C)
                     return tmp.t;
             }
         }
     }
     return -;
 }
 void print(int u)
 {
     if(u==)
         printf("FILL(1)\n");
     else if(u==)
         printf("FILL(2)\n");
     else if(u==)
         printf("DROP(1)\n");
     else if(u==)
         printf("DROP(2)\n");
     else if(u==)
         printf("POUR(1,2)\n");
     else if(u==)
         printf("POUR(2,1)\n");
 }
 int main()
 {
     while(scanf("%d%d%d",&Va,&Vb,&C)!=EOF)
     {
         memset(vis,,sizeof(vis));
         pre.clear();
         int ans=bfs();
         if(ans==-)
             printf("impossible\n");
         else
         {
             printf("%d\n",ans);
             memset(a,,sizeof(a));
             int p=pre.size()-;
             int cnt=;
             while(pre[p].last!=-)
             {
                 a[++cnt]=pre[p].step;
                 p=pre[p].last;
             }
             for(int i=cnt;i>=;i--)
                 print(a[i]);
         }
     }
     return ;
 }