POJ3414

最新推荐文章于 2020-06-17 01:14:35 发布

壮志小青年

最新推荐文章于 2020-06-17 01:14:35 发布

阅读量558

点赞数

分类专栏：图

本文链接：https://blog.csdn.net/qq_43450892/article/details/105412615

版权

图专栏收录该内容

4 篇文章 0 订阅

订阅专栏

POJ3414pots

这些bfs题都很妙啊，多做做肯定有好处的

思路:
每到一次可以作为一个方向，总共有6种方向
①把A装满
②把B装满
③把A倒了
④把B倒了
⑤把A倒入B
⑥把B倒入A
其实就是bfs，每次操作先看看是否到达过，然后标记，然后顺着找。总共三个数（100以内），能有多少种组合？
直接用二维数组就可以

#include <iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
int a,b,c;
int vis [105][105];
struct node
{
    int u,v;
    int level;
    int caozuo;
    int id;
    int pre;
    node(int a,int a1,int a2,int a3,int a4,int a5)
    {
        u=a;
        v=a1;
        level=a2;
        caozuo=a3;
        id=a4;
        pre=a5;
    }
};
vector<node> arr;
int cnt=0;
int ans;

string str[]=
{
    "FILL(1)",
    "FILL(2)",
    "DROP(1)",
    "DROP(2)",
    "POUR(1,2)",
    "POUR(2,1)"
};
void bfs()
{
    queue<node> cun;
    cun.push(node(0,0,0,-1,0,-1));
    arr.push_back(node(0,0,0,-1,0,-1));
    memset(vis,0,sizeof(vis));
    vis[0][0]=1;
    cnt++;
    ans=-1;
    while(!cun.empty())
    {
        node tmp=cun.front();
        cun.pop();
        if(tmp.u==c||tmp.v==c)
        {
            ans=tmp.id;
            break;
        }

        for(int i=0; i<6; i++)
        {
            if(i==0)            //fill a
            {
                if(a-tmp.u>0&&vis[a][tmp.v]==0)
                {
                    vis[a][tmp.v]=1;
                    node n(a,tmp.v,tmp.level+1,i,cnt,tmp.id);
                    cnt++;
                    arr.push_back(n);
                    cun.push(n);
                }
            }
            else if(i==1) //fill b
            {
                if(b-tmp.v>0&&vis[tmp.u][b]==0)
                {
                    vis[tmp.u][b]=1;
                    node n(tmp.u,b,tmp.level+1,i,cnt,tmp.id);
                    cnt++;
                    arr.push_back(n);
                    cun.push(n);
                }
            }
            else if(i==2) //d a
            {
                if(tmp.u>0&&vis[0][tmp.v]==0)
                {
                    vis[0][tmp.v]=1;
                    node n(0,tmp.v,tmp.level+1,i,cnt,tmp.id);
                    cnt++;
                    arr.push_back(n);
                    cun.push(n);
                }
            }
            else if(i==3) //d b
            {
                if(tmp.v>0&&vis[tmp.u][0]==0)
                {
                    vis[tmp.u][0]=1;
                    node n(tmp.u,0,tmp.level+1,i,cnt,tmp.id);
                    cnt++;
                    arr.push_back(n);
                    cun.push(n);
                }
            }
            else if(i==4) //1->2
            {
                if(tmp.u!=0&&tmp.v!=b)
                {
                    int dao=min(b-tmp.v,tmp.u);
                    if(vis[tmp.u-dao][tmp.v+dao]==0)
                    {
                        vis[tmp.u-dao][tmp.v+dao]=1;
                        node n(tmp.u-dao,tmp.v+dao,tmp.level+1,i,cnt,tmp.id);
                        cnt++;
                        arr.push_back(n);
                        cun.push(n);
                    }

                }
            }
            else if(i==5)
            {
                if(tmp.v!=0&&tmp.u!=a)
                {
                    int dao=min(a-tmp.u,tmp.v);
                    if(vis[tmp.u+dao][tmp.v-dao]==0)
                    {
                        vis[tmp.u+dao][tmp.v-dao]=1;
                        node n(tmp.u+dao,tmp.v-dao,tmp.level+1,i,cnt,tmp.id);
                        cnt++;
                        arr.push_back(n);
                        cun.push(n);
                    }

                }
            }

        }
    }

    if(ans!=-1)
    {
        node tmp=arr[ans];
        int cnt=0;
        stack<int> arrx;
        while(1)
        {
            if(tmp.caozuo>=6||tmp.caozuo<0)
                break;
            arrx.push(tmp.caozuo);
            ans=tmp.pre;
            if(ans==-1)
                break;
            tmp=arr[tmp.pre];
            cnt++;
        }
        cout<<cnt<<endl;
        while(!arrx.empty())
        {
            int t1=arrx.top();
            arrx.pop();
            cout<<str[t1]<<endl;
        }
    }
    else
        cout<<"impossible"<<endl;

}
int main()
{
    cin>>a>>b>>c;

    bfs();


    return 0;
}