poj 3414 Pots（BFS+路径输出）

问题：

给出两个水壶的规格a、b，并给出需要的水体积c，有6种操作：灌满a，灌满b，把a倒向b（有两种状态：一种b满了a有剩余，一种a全倒入了b），把b倒向a（同样两种状态），把a倒入下水道，把b倒入下水道。问任一水壶达到c状态的操作次数和路径（或者impossible）

解法：

运用bfs搜索每次操作，每达到一种状态，都会有6种路径要走，这6种路径是平行的。判定条件：当队列空时，还没有找到c状态，则impossible

AC代码：

#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <cstring>
using namespace std;
int a,b,c;
int flag; //用来判定impossible
map<int,string>maps;
void mapss()  //列出6种路径
{
    maps[0]="FILL(1)";
    maps[1]="FILL(2)";
    maps[2]="DROP(1)";
    maps[3]="DROP(2)";
    maps[4]="POUR(1,2)";
    maps[5]="POUR(2,1)";
}
int vis[201][201]; //标记数组
struct node
{
    int literA,literB; //a中的水，b中的水
    int counts; //记录到达当前状态后的次数
    int num[100];
};

void bfs(node aaa)
{
    node now,next;
    queue<node>q;
    q.push(aaa);
    vis[aaa.literA][aaa.literB]=1;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.literA==c||now.literB==c)  //若符合条件，输出路径并返回
        {

            cout<<now.counts<<endl;
            for(int i=1;i<=now.counts;i++)
            {
                cout<<maps[now.num[i]]<<endl;
            }
            return;
        }
        for(int i=0;i<6;i++)  //开始走接下来的6种路径
        {
            node tmp=now;
            if(i==0)
            {
                tmp.literA=a;
                tmp.counts=now.counts+1;
            }
            if(i==1)
            {
                tmp.literB=b;
                tmp.counts=now.counts+1;
            }
            if(i==2)
            {
                tmp.literA=0;
                tmp.counts=now.counts+1;
            }
            if(i==3)
            {
                tmp.literB=0;
                tmp.counts=now.counts+1;
            }
            if(i==4)
            {
                if(tmp.literA+tmp.literB>=b)
                {
                    int need=b-tmp.literB;
                    tmp.literB=b;
                    tmp.literA-=need;
                    tmp.counts=now.counts+1;
                }
                else
                {
                    tmp.literB+=tmp.literA;
                    tmp.literA=0;
                    tmp.counts=now.counts+1;
                }
            }
            if(i==5)
            {
                if(tmp.literA+tmp.literB>=a)
                {
                    int need=a-tmp.literA;
                    tmp.literA=a;
                    tmp.literB-=need;
                    tmp.counts=now.counts+1;
                }
                else
                {
                    tmp.literA+=tmp.literB;
                    tmp.literB=0;
                    tmp.counts=now.counts+1;
                }
            }
            for(int j=1;j<=now.counts;j++)  //该状态符合条件，记录之前以及当前的路径
            {
                tmp.num[j]=now.num[j];
            }
            tmp.num[tmp.counts]=i;
            next=tmp;
            if(vis[next.literA][next.literB]>0) //判定条件，之前出现过，则跳到下一个循环 不能直接return impossible
            {
                continue;
            }
            vis[next.literA][next.literB]=1;
            q.push(next);
        }

    }
    flag=-1;
    return;
}
int main()
{
    mapss();
    while(cin>>a>>b>>c)
    {
        flag=1;
        memset(vis,0,sizeof(vis));
        node now;
        now.literA=0;
        now.literB=0;
        now.counts=0;
        bfs(now);
        if(flag==-1)
            cout<<"impossible"<<endl;

    }
    return 0;
}