kuangbin专题 专题一 简单搜索 Pots POJ - 3414

题目链接：https://vjudge.net/problem/POJ-3414

题意：给你两个杯子，分别容量为A(1)，B(2)和一个C，C是需要经过下列操作，得到的一个升数。
（1） FILL(i) ：把编号为i的杯子中水灌满
（2）DROP（i）：把编号为i的杯子中水全部倒了
（3）POUR（i,j）：把编号为i的杯子中的水倒入编号为j的杯子中，如果编号j杯子中水满了，编号i杯子水就不继续倒了
问：能不能经过有限次（1）（2）（3）操作，得到A,B中其中一个满足C升的水就可以，可以的话输出最少次数并把操作输出，否则输出“impossble”

思路：最少，容易想到bfs，加上倒水过程的模拟，也就6种情况，模拟操作预处理之后，后面会变得很好写，其中的过程，看代码注释吧。
补：我们可以把A，B中升数情况给记录下，出现过的<A,B>就不需要再次bfs了，不然应该会TLE

---

 #include <iostream>
 #include <cstring>
 #include<vector>
 #include<string>
 #include <cmath>
 #include <map>
 #include <queue>
 #include <algorithm>
 using namespace std;

 #define inf (1LL << 31) - 1
 #define rep(i,j,k) for(int i = (j); i <= (k); i++)
 #define rep__(i,j,k) for(int i = (j); i < (k); i++)
 #define per(i,j,k) for(int i = (j); i >= (k); i--)
 #define per__(i,j,k) for(int i = (j); i > (k); i--)

 int A_L, B_L, C_L;

 //六种操作，都先预处理好
 string op[] = { "FILL(1)", "FILL(2)", "DROP(1)", "DROP(2)",
                 "POUR(1,2)", "POUR(2,1)" };
 //其实算一个类用
 struct node{

     int A,B; //A，B杯子中水升数情况
     vector<string > str; //记录操作
 //    int l;
     node(int a = , int b = ){ A = a; B = b; }

     void Fill(int num){ //（1）操作处理
         if (num == ) A = A_L;
         else B = B_L;
     }

     void Drop(int num){ //（2）操作处理
         if (num == ) A = ;
         else B = ;
     }

     void Pour(int num){ //（3）操作处理
         if (num == ){
             int tmp = A;
             A -= (A >= B_L - B ? (B_L - B) : A);
             B = (tmp >= B_L - B ? B_L : B + tmp);
         }
         else{
             int tmp = B;
             B -= (B >= A_L - A ? (A_L - A) : B);
             A = (tmp >= A_L - A ? A_L : A + tmp);
         }
     }

 };

 void fun(string str){
     cout << str << endl;
 }

 void bfs(){

     map<pair<int, int>, bool> mp;  //记录<A,B>的情况

     node init;
     /*
     pair<int,int > p (init.A, init.B);
     mp[p] = true;
     */

     queue<node> que;
     que.push(init);

     while (!que.empty()){

         node key = que.front();
         que.pop();

         pair<int, int> o( key.A, key.B );
         if (mp[o]) continue; //判断这个<A,B>有误出现过，出现了就不继续下去了
         mp[o] = true; //没出现过，标记一下

         //六种情况
         rep(p, , ){

             node tmp = key;

             if (p == ) tmp.Fill(),tmp.str.push_back(op[]);
             else if (p == ) tmp.Fill(), tmp.str.push_back(op[]);
             else if (p == ) tmp.Drop(), tmp.str.push_back(op[]);
             else if (p == ) tmp.Drop(), tmp.str.push_back(op[]);
             else if (p == ) tmp.Pour(), tmp.str.push_back(op[]); //pour(1,2)
             else if (p == ) tmp.Pour(), tmp.str.push_back(op[]); //pour(2,1)

             //其中一个满足即可
             if (tmp.A == C_L || tmp.B == C_L){
                 cout << (int)tmp.str.size() << endl;

                 //遍历tmp的vector
                 for_each(tmp.str.begin(), tmp.str.end(), fun);

                 return;
             }

             o = make_pair(tmp.A, tmp.B); //也是判断下新的<A,B>是否出现过
             if (!mp[o]) que.push(tmp); //出现过，不再压入队列
         }
     }

     //无法得出C
     cout << "impossible" << endl;

 }

 int main(){

     ios::sync_with_stdio(false);
     cin.tie();

     cin >> A_L >> B_L >> C_L; //记录A的最大容量，B的最大容量，标准C
     bfs();

     return ;
 }