poj 3414 Pots bfs+模拟

简介:

#include<iostream> 
#include<cstring>
#define fillA 1
#define pourAB 2
#define dropA 3
#define fillB 4
#define pourBA 5
#define dropB 6

#define N 10000

using namespace std;
int vis[105][105];
class node
{
public:
   int A, B;
   int dir;
   node()
   {
      A=0;
      B=0;
   }
};

int a, b, c, tot;
node q[N];
int pre[N];

void printPath(int index)
{
   if(index==0)
   {
       cout<<tot<<endl; 
       return ;
   } 
   ++tot;
   printPath(pre[index]);
   switch(q[index].dir)
   {
      case 1:
           cout<<"FILL(1)";
           break;
      case 2:
           cout<<"POUR(1,2)";
           break;
      case 3:
           cout<<"DROP(1)";
           break;
      case 4:
           cout<<"FILL(2)";
           break;
      case 5:
           cout<<"POUR(2,1)";
           break;
      case 6:
           cout<<"DROP(2)";
           break;
   }
   cout<<endl;
}

int bfs()
{
   int head=0, rear=1, r;
   node cur, next;
   memset(vis, 0, sizeof(vis));
   pre[0]=0;
   vis[0][0]=1;
   while(head<rear)
   {
       cur=q[head];
       if(cur.A==c || cur.B==c)
       {
             printPath(head);
             return 1;
       }
       next=cur;
       if(!vis[a][cur.B])//将 A 装满 
       {
             next.A=a;
             next.dir=fillA;
             pre[rear]=head;
             vis[a][cur.B]=1;
             q[rear++]=next;
       }
       if(!vis[0][cur.B])//将 A 倒掉 
       {
             next.A=0;
             next.dir=dropA;
             pre[rear]=head;
             vis[0][cur.B]=1;
             q[rear++]=next;
       }
       r=b-cur.B;
       next.dir=pourAB;
       if(r>cur.A && !vis[0][cur.B+cur.A])//将A 倒向 B 
       {
             next.A=0;
             next.B=cur.B+cur.A;
             pre[rear]=head;
             q[rear++]=next;
             vis[0][cur.B+cur.A]=1;
       }
       else if(r<=cur.A && !vis[cur.A-r][cur.B+r])
       {
             next.A=cur.A-r;
             next.B=cur.B+r;
             pre[rear]=head;
             q[rear++]=next;
             vis[cur.A-r][cur.B+r]=1;
       }
       
       next=cur;//开始错在这里了, 忘记了从新给next赋值了
       if(!vis[cur.A][b])//将 B 装满 
       {
             next.B=b;
             next.dir=fillB;
             pre[rear]=head;
             q[rear++]=next;
             vis[cur.A][b]=1;
       }
       if(!vis[cur.A][0])//将 B 倒掉 
       {
             next.B=0;
             next.dir=dropB;
             pre[rear]=head;
             q[rear++]=next;
             vis[cur.A][0]=1;
       }
       r=a-cur.A;
       next.dir=pourBA;
       if(r>cur.B && !vis[cur.B+cur.A][0])//将B 倒向 A
       {
             next.B=0;
             next.A=cur.B+cur.A;
             pre[rear]=head;
             q[rear++]=next;
             vis[cur.B+cur.A][0]=1;
       }
       else if(r<=cur.B && !vis[cur.A+r][cur.B-r])
       {
             next.A=cur.A+r;
             next.B=cur.B-r;
             pre[rear]=head;
             q[rear++]=next;
             vis[cur.A+r][cur.B-r]=1;
       }
      ++head;  
   }
   return 0;
}

int main()
{
   while(cin>>a>>b>>c)
   {
      tot=0;
      if(c>a && c>b)
      {
         cout<<"impossible"<<endl;
         continue;
      }
      if(!bfs())
         cout<<"impossible"<<endl;
   }
   return 0;
}

目录
相关文章
|
6月前
|
算法
数据结构与算法-DFS+BFS篇(迷宫问题)
数据结构与算法-DFS+BFS篇(迷宫问题)
86 3
|
6月前
|
存储 算法
算法BFS经典例题(迷宫,多源BFS,BFS解决拓扑排序,FloodFill算法)
算法BFS经典例题(迷宫,多源BFS,BFS解决拓扑排序,FloodFill算法)
|
7月前
poj 3984 迷宫问题(BFS+输出路径)
poj 3984 迷宫问题(BFS+输出路径)
30 0
poj 1068 模拟
大概题意就是告诉你有个n个小括号,每一个“)”左边有多少个“(”都告诉你了,然后让你求出每一对括号之间有多少对括号(包含自己本身)。 思路: 我先计算每个“)”左边有多少个“(”要匹配,然后每遇到一个“)”,然后向前寻找第一个可以匹配的“(”,找到后将其数量减一,这样的话在寻找的过程中经过了几个“)”就表示这对括号里面有多少括号。
27 0
|
算法
从三道leetcode掌握深度优先搜索(DFS)
前言 无论在算法面试还是刷题中,深度优先搜索(DFS)和广度优先搜索(BFS)都是一个绕不过去的坎。不同于数组的从左至右遍历,循环常用于一维数据结构的遍历。而DFS和BFS则常用于多维数据结构的遍历,最常见的莫过于嵌套结构的多叉树了。
|
存储
Leetcode-每日一题1210. 穿过迷宫的最少移动次数(BFS)
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_46618592/article/details/128890280?spm=1001.2014.3001.5501
120 0
Leetcode-每日一题1210. 穿过迷宫的最少移动次数(BFS)
|
算法 Java
hdu1181变形课dfs/bfs/并查集三种解法(java)
呃…变形课上Harry碰到了一点小麻烦,因为他并不像Hermione那样能够记住所有的咒语而随意的将一个棒球变成刺猬什么的,但是他发现了变形咒语的一个统一规律:如果咒语是以a开头b结尾的一个单词,那么它的作用就恰好是使A物体变成B物体. Harry已经将他所会的所有咒语都列成了一个表,他想让你帮忙计算一下他是否能完成老师的作业,将一个B(ball)变成一个M(Mouse),你知道,如果他自己不能完成的话,他就只好向Hermione请教,并且被迫听一大堆好好学习的道理.
187 0