Pots POJ

典型的倒水问题：

即把两个水杯的每种状态视为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[105][105];
int a[10000];
queue<pot>que;
vector<pot>pre;
int bfs()
{
    while(!que.empty())
        que.pop();
    pot s=pot{0,0,-1,0,0,-1};
    que.push(s);
    vis[0][0]=1;
    pre.push_back(s);
    while(!que.empty())
    {
        pot now=que.front();
        que.pop();
        for(int i=0;i<6;i++)
        {
            pot tmp=now;
            if(i==0)//fill(1)
                tmp.a=Va;
            else if(i==1)//fill(2)
                tmp.b=Vb;
            else if(i==2)//drop(1)
                tmp.a=0;
            else if(i==3)//drop(2)
                tmp.b=0;
            else if(i==4)//pour(1,2)
            {
                if(tmp.a>Vb-tmp.b)
                {
                    tmp.a-=(Vb-tmp.b);
                    tmp.b=Vb;
                }
                else
                {
                    tmp.b+=tmp.a;
                    tmp.a=0;
                }
            }
            else if(i==5)//pour(2,1)
            {
                if(tmp.b>Va-tmp.a)
                {
                    tmp.b-=(Va-tmp.a);
                    tmp.a=Va;
                }
                else
                {
                    tmp.a+=tmp.b;
                    tmp.b=0;
                }
            }
            if(!vis[tmp.a][tmp.b])
            {
                tmp.step=i;
                tmp.t=now.t+1;
                tmp.last=now.my;
                pre.push_back(tmp);
                tmp.my=pre.size()-1;
                vis[tmp.a][tmp.b]=1;
                que.push(tmp);
                if(tmp.a==C||tmp.b==C)
                    return tmp.t;
            }
        }
    }
    return -1;
}
void print(int u)
{
    if(u==0)
        printf("FILL(1)
");
    else if(u==1)
        printf("FILL(2)
");
    else if(u==2)
        printf("DROP(1)
");
    else if(u==3)
        printf("DROP(2)
");
    else if(u==4)
        printf("POUR(1,2)
");
    else if(u==5)
        printf("POUR(2,1)
");
}
int main()
{
    while(scanf("%d%d%d",&Va,&Vb,&C)!=EOF)
    {
        memset(vis,0,sizeof(vis));
        pre.clear();
        int ans=bfs();
        if(ans==-1)
            printf("impossible
");
        else
        {
            printf("%d
",ans);
            memset(a,0,sizeof(a));
            int p=pre.size()-1;
            int cnt=0;
            while(pre[p].last!=-1)
            {
                a[++cnt]=pre[p].step;
                p=pre[p].last;
            }
            for(int i=cnt;i>=1;i--)
                print(a[i]);
        }
    }
    return 0;
}