2. 程式人生 > >poj 3414 路徑輸出的bfs（pre)

poj 3414 路徑輸出的bfs（pre)

阿新 • • 發佈：2019-02-05
  1. #include <iostream>
  2. #include <algorithm>
  3. usingnamespace std;  
  4. #include <cstring>
  5. #include <queue>
  6. #include <stack>
  7. struct cup  
  8. {  
  9.     int x, y;  
  10.     int step;  
  11.     int flag;//標記操作
  12.     cup *pre;//記錄路徑
  13. };  
  14. queue<cup>Q;  
  15. stack<int>R;  
  16. int a, b, e;  
  17. int vis[117][117]={0};
    //標記當前狀態是否到達過
  18. int ans;  
  19. void BFS(int x, int y)  
  20. {  
  21.     cup c;  
  22.     cup t[317];//目前瓶子裡剩餘的水量
  23.     c.x = 0, c.y = 0;  
  24.     c.flag = 0;  
  25.     c.pre = NULL;  
  26.     c.step = 0;  
  27.     Q.push(c);  
  28.     vis[x][y] = 1;  
  29.     int count = -1;  
  30.     while(!Q.empty())  
  31.     {  
  32.         count++;  
  33.         t[count] = Q.front();  
  34.         Q.pop();  
  35.         for(int i = 1; i <= 6; i++)  
  36.         {  
  37.             switch(i)  
  38.             {  
  39.                 case 1:                     //fill a
  40.                     c.x = a;  
  41.                     c.y = t[count].y;  
  42.                     c.flag = 1;  
  43.                     break;  
  44.                 case
     2:                     //fill b
  45.                     c.x = t[count].x;  
  46.                     c.y = b;  
  47.                     c.flag = 2;  
  48.                     break;  
  49.                 case 3:                     //drop a
  50.                     c.x = 0;  
  51.                     c.y = t[count].y;  
  52.                     c.flag = 3;  
  53.                     break;  
  54.                 case 4:                     //drop b
  55.                     c.x = t[count].x;  
  56.                     c.y = 0;  
  57.                     c.flag = 4;  
  58.                     break;  
  59.                 case 5:                     //pour a to b
  60.                     if(t[count].x > b-t[count].y)  
  61.                     {  
  62.                         c.x = t[count].x-(b-t[count].y);  
  63.                         c.y = b;  
  64.                     }  
  65.                     else
  66.                     {  
  67.                         c.x = 0;  
  68.                         c.y = t[count].y+t[count].x;  
  69.                     }  
  70.                     c.flag = 5;  
  71.                     break;  
  72.                 case 6:                     //pour b to a
  73.                     if(t[count].y > a-t[count].x)  
  74.                     {  
  75.                         c.y = t[count].y - (a-t[count].x);  
  76.                         c.x = a;  
  77.                     }  
  78.                     else
  79.                     {  
  80.                         c.x = t[count].x+t[count].y;  
  81.                         c.y = 0;  
  82.                     }  
  83.                     c.flag = 6;  
  84.                     break;  
  85.             }  
  86.             if(vis[c.x][c.y])  
  87.                 continue;  
  88.             vis[c.x][c.y] = 1;  
  89.             c.step = t[count].step+1;  
  90.             c.pre = &t[count];  
  91.             if(c.x == e || c.y == e)  
  92.             {  
  93.                 ans = c.step;  
  94.                 while(c.pre)  
  95.                 {  
  96.                     R.push(c.flag);  
  97.                     c = *c.pre;  
  98.                 }  
  99.                 return;  
  100.             }  
  101.             Q.push(c);  
  102.         }  
  103.     }  
  104. }  
  105. void print()  
  106. {  
  107.     while(!R.empty())  
  108.     {  
  109.         int i = R.top();  
  110.         R.pop();  
  111.         switch(i)  
  112.         {  
  113.             case 1:cout<<"FILL(1)"<<endl;break;  
  114.             case 2:cout<<"FILL(2)"<<endl;break;  
  115.             case 3:cout<<"DROP(1)"<<endl;break;  
  116.             case 4:cout<<"DROP(2)"<<endl;break;  
  117.             case 5:cout<<"POUR(1,2)"<<endl;break;  
  118.             case 6:cout<<"POUR(2,1)"<<endl;break;  
  119.         }  
  120.     }  
  121. }  
  122. int main()  
  123. {  
  124.     cin >>a>>b>>e;  
  125.     BFS(0,0);  
  126.     if(ans == 0)  
  127.         cout<<"impossible"<<endl;  
  128.     else
  129.     {  
  130.         cout<<ans<<endl;  
  131.         print();  
  132.     }  
  133.     return 0;  
  134. }  

相關推薦

poj 3414 路徑輸出的bfs（pre)

#include <iostream> #include <algorithm> usingnamespace std;   #include <cstring>

POJ 3414 Pot (輸出路徑)【BFS】

至少 ret ref string 狀況 nod size 推導 blank <題目鏈接> 題目大意： 有兩個容量的空杯子，能夠對這兩個空杯子進行三種操作： 分別是fill(a)，裝滿a杯子； drop(a)，倒空a杯子； pour(a,b)，將a杯子中的水倒入

poj 3414 Pots 廣搜（鏈式儲存）

1.題意：有兩個罐子A,B,可以進行三種操作， FILL(i)        fill the pot i (1 ≤ i ≤ 2) from the tap;//把第i個罐子裝滿；DROP(i)      empty the pot i to the drain;//把第i

poj 3414 Pots（廣搜BFS+路徑輸出）

contents imp 進行 ace main 數組 ems string oid 轉載請註明出處：http://blog.csdn.net/u012860063?viewmode=contents 題目鏈接：http://poj.org/problem?id=3414

poj 3414 Pots（bfs+輸出回溯路徑）

給你兩個容器，分別能裝下A升水和B升水，並且可以進行以下操作 FILL(i) 將第i個容器從水龍頭裡裝滿(1 ≤ i ≤ 2); DROP(i) 將第i個容器抽乾 POUR(i,j) 將第i個容

poj 3414 Pots （bfs+路徑記錄）

Pots Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 10071 Accepted: 4237 Special Judge Description You are given two

POJ ~ 3414 ~ Pots （BFS+列印路徑）

題意：有兩個無刻度的容量分別為A,B升的杯子，通過一些操作使某一個杯子中有C升的水。 1. FILL(i) ，將i這個杯子中的水接滿 2. DROP(i)，將i這個杯子中的水倒掉 3. POUR(i,j)，將i這個杯子中的水倒入j這個杯子，能倒完就倒完，倒不完就留在杯子中。

POJ-3414 POTS（BFS列印路徑）

問題描述 You are given two pots, having the volume of A and B liters respectively. The following operations can be performed: FILL(i

POJ 3414 Pots（BFS記錄路徑）

Pots Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 10085 Accepted: 4245 Special Judge Description You are given two p

POJ 3436 ACM Computer Factory（最大流+路徑輸出）

push_back factory flow open clas 小時 compute 臺電腦 mat http://poj.org/problem?id=3436 題意： 每臺計算機包含P個部件，當所有這些部件都準備齊全後，計算機就組裝完成了。計算機的生產過程通過N臺

POJ 3414 （BFS）

class cout () amp esp cst LV pan span 這道題還是比較簡單的，就是寫起來有點麻煩，剛開始做的時候一直一位有什麽簡單方法，拖了好久。。。還是自己分析問題的能力不行啊 1 #include<iostream> 2 #i

Pots POJ - 3414 (廣搜 + 路徑輸出 + 倒水問題)

https://vjudge.net/problem/POJ-3414. 大概看了一下, 倒水問題 + 路徑輸出, 杯子不多就兩個, 方法不多就3個, 範圍不大就100, 所以總體看起來不算太難 這裡我用了vector加head和tail來模擬佇列, 因為用queue的話一旦pop出去的點就

POJ 3414　Pots 均分水（bfs）

題目連結： 題目大意： 有兩個水杯，一開始都沒有裝水，給出兩個水杯的容量，和要達到的目標容量 每個水被有三種操作：１．裝滿水，２．倒掉所有水，３，將水倒入另一個杯子中． 思路： 兩個杯子，六種操作，，求最短路，並列印路徑，６入口b

poj 3414 bfs 兩個壺倒水，記錄路徑

題意：給你兩個壺，容量分別為a，b，初始都是0，再給你一個目標水量c，問經過幾次操作可以使得其中一個壺的水量為目標水量c，並且把操作步驟輸出。 6個操作： 1、FILL（1）//FILL（i）,把 i 壺裝滿 2、FILL（2） 3、DROP（1）//DROP（i），把 i

POJ-3414-Pots（BFS 模擬）

H - Pots Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%I64d & %I64u Submit Status Practice POJ 3414 App

UVa 11419 我是SAM（最小點覆蓋+路徑輸出）

二分圖 現在 over div space void net https 最小點覆蓋 https://vjudge.net/problem/UVA-11419 題意：一個網格裏面有一些目標，可以從某一行，某一列發射一發子彈，可以打掉它；求最少的子彈，和在哪裏打？

POJ 1426 Find The Multiple（DFS，BFS）

ons pro sum 數字 there lin queue hat 一個數 Given a positive integer n, write a program to find out a nonzero multiple m of n whose decimal

POJ 3278 Catch That Cow（模板——BFS）

out print rate clas 鏈接 else ccf div ret 題目鏈接：http://poj.org/problem?id=3278 Description Farmer John has been informed of the location of

HDU 1026 Ignatius and the Princess I(BFS+路徑輸出）

namespace any who 相同 i++ cmp fine and spa Ignatius and the Princess I Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768

UOJ 117 歐拉回路（套圈法+歐拉回路路徑輸出+騷操作）

height int ima 標記 圖片 style 技術分享 () targe 題目鏈接：http://uoj.ac/problem/117 題目大意： 解題思路：先判斷度數： 　　　　　若G為有向圖，歐拉回路的點的出度等於入度。 　　　　　若G為無向圖，歐拉