Pots（BFS）

Pots

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 31   Accepted Submission(s) : 14

Special Judge

Problem Description

You are given two pots, having the volume of A and B liters respectively. The following operations can be performed:

1. FILL(i)        fill the pot i (1 ≤ i ≤ 2) from the tap;
2. DROP(i)      empty the pot i to the drain;
3. POUR(i,j)    pour from pot i to pot j; after this operation either the pot j is full (and there may be some water left in the pot i), or the pot i is empty (and all its contents have been moved to the pot j).

Write a program to find the shortest possible sequence of these operations that will yield exactly C liters of water in one of the pots.

 

Input

On the first and only line are the numbers A, B, and C. These are all integers in the range from 1 to 100 and C≤max(A,B).

 

Output

The first line of the output must contain the length of the sequence of operations K. The following K lines must each describe one operation. If there are several sequences of minimal length, output any one of them. If the desired result can’t be achieved, the first and only line of the file must contain the word ‘impossible’.

 

Sample Input

3 5 4

 

Sample Output

6

FILL(2)

POUR(2,1)

DROP(1)

POUR(2,1)

FILL(2)

POUR(2,1)

 

Source

PKU

题意：给出不定数量的样例，每个样例一行，有三个整数，a，b，c，a和b代表两个杯子的容量，c是希望得到的液体体积，一开始两个杯子都是空的，如果利用两个杯子可以倒出c则输出最小的步数和倒出c的步骤；

对两个杯子可以进行以下操作：

FILL(i)：装满第i个杯子；

POUR(i，j)：从第i个杯子向第j个杯子中倒水；

DROP(i)：清空第i个杯子；

思路：

利用BFS进行搜索，求出最小部属并输出；注意对于每一个状态都可能有六种操作，在进行每一种操作前都要进行判断该操作可以进行吗。

AC代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>

 using namespace std;
 struct node
 {
     int aa;
     int bb;
     int sgin;//父亲节点
     int sp;//父亲节点到该点的操作
 };
 int a,b,c;
 int ff=;
 node sk[];//队列
 bool sg[][];//记录节点的访问属性
 int kiss[];//记录操作

 void s1(node &s,int m)//操作1：把a倒满
 {
     s.aa=a;
     s.sgin=m;//记录下父亲节点的位置
     s.sp=;//记录下有父亲节点到达该点的操作
 }
 void s2(node &s,int m)//操作2：把b倒满
 {
     s.bb=b;
     s.sgin=m;
     s.sp=;
 }
 void s3(node &s,int m)//操作3：把a清空
 {
     s.aa=;
     s.sgin=m;
     s.sp=;
 }
 void s4(node &s,int m)//操作4：把b清空
 {
     s.bb=;
     s.sgin=m;
     s.sp=;
 }
 void s5(node &s,int m)//操作5：从a中向b中到溶液
 {
     if(s.aa+s.bb<=b){
         s.bb+=s.aa;
         s.aa=;
         s.sgin=m;
         s.sp=;
     }
     else{
         s.aa=s.aa-(b-s.bb);
         s.bb=b;
         s.sgin=m;
         s.sp=;
     }
 }
 void s6(node &s,int m)//操作6：从b中向a中到溶液
 {
     if(s.bb+s.aa<=a){
         s.aa+=s.bb;
         s.bb=;
         s.sgin=m;
         s.sp=;
     }
     else{
         s.bb=s.bb-(a-s.aa);
         s.aa=a;
         s.sgin=m;
         s.sp=;
     }
 }

 int ss(node x)//找出步骤
 {
     while(){
         if(x.sp==)
             break;
         kiss[ff++]=x.sp;
         x=sk[x.sgin];
     }
     return ;
 }

 int bfs()
 {
     sk[].aa=;//初始化条件
     sk[].bb=;
     sk[].sgin=;
     sk[].sp=;//挑出步骤的跳出条件
     sg[][]=true;
     int le=,ri=;
     while(le<ri){
         node x=sk[le];
         if(x.aa==c||x.bb==c){//利用两个杯子倒出了容量c
             ss(x);
             return ;//利用两个杯子可以倒出容量c，则返回1
         }
         if(x.aa!=a){//进行操作1时要判断a是否是满的，如果a是满的则不可以进行操作1
             s1(x,le);
             if(sg[x.aa][x.bb]==false){//操作1进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
             x=sk[le];
         }
         if(x.bb!=b){//如果b是满的则不可以进行操作2
             s2(x,le);
             if(sg[x.aa][x.bb]==false){//操作2进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
             x=sk[le];
         }
         if(x.aa!=){//如果a是空的则不可以进行操作3
             s3(x,le);
             if(sg[x.aa][x.bb]==false){//操作3进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
             x=sk[le];
         }
         if(x.bb!=){//如果b是空的则不可以进行操作4
             s4(x,le);
             if(sg[x.aa][x.bb]==false){//操作4进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
             x=sk[le];
         }
         if(x.aa!=){//如果a是空的则不可以进行操作5
             s5(x,le);
             if(sg[x.aa][x.bb]==false){//操作5进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
             x=sk[le];
         }
         if(x.bb!=){//如果b是空的则不可以进行操作6
             s6(x,le);
             if(sg[x.aa][x.bb]==false){//操作6进行后，产生了新的点，检验该点被访问你过吗，若果该点别访问过着不可以插入到队列了面
                 sk[ri++]=x;
                 sg[x.aa][x.bb]=true;
             }
         }
         le++;
     }
     return ;//利用两个杯子不可以倒出容量c，则返回0；
 }

 int main()
 {
 //    freopen("input.txt","r",stdin);
     while(cin>>a>>b>>c){
         memset(sg,false,sizeof(sg));
         memset(kiss,,sizeof(kiss));
         ff=;
         int skn=bfs();
         if(skn==){
             cout<<ff<<endl;
             ff--;
             while(ff>=)
             {
                 if(kiss[ff]==){
                     cout<<"FILL(1)"<<endl;
                 }
                 if(kiss[ff]==){
                     cout<<"FILL(2)"<<endl;
                 }
                 if(kiss[ff]==){
                     cout<<"DROP(1)"<<endl;
                 }
                 if(kiss[ff]==){
                     cout<<"DROP(2)"<<endl;
                 }
                 if(kiss[ff]==){
                     cout<<"POUR(1,2)"<<endl;
                 }
                 if(kiss[ff]==){
                     cout<<"POUR(2,1)"<<endl;
                 }
                 ff--;
             }
         }
         else{
             cout<<"impossible"<<endl;
         }
     }
     return ;
 }

网上他人的代码：

 #include<iostream>
 #include<string>
 #include<cstdio>
 #include<cstring>

 using namespace std;

 const int maxn=;

 string op[]={"","FILL(1)","FILL(2)","DROP(1)","DROP(2)","POUR(2,1)","POUR(1,2)"};

 int l,r;
 int a,b,c;
 int vis[maxn][maxn],step[maxn*maxn];

 struct node{
     int x,y;
     int opr;
     int pre;
 }info[maxn*maxn];

 void Solve(int x,int y,int opr){
     if(vis[x][y])
         return ;
     vis[x][y]=;
     info[r].x=x;
     info[r].y=y;
     info[r].opr=opr;
     info[r].pre=l;
     r++;
 }

 void Print(){
     int ans=;
     while(l!=){
         step[ans++]=info[l].opr;
         l=info[l].pre;
     }
     printf("%d\n",ans);
     for(int i=ans-;i>=;i--)
         cout<<op[step[i]]<<endl;
 }

 void BFS(){
     info[].x=;
     info[].y=;
     vis[][]=;
     l=;
     r=;
     int tx,ty;
     while(l!=r){
         if(info[l].x==c || info[l].y==c){
             Print();
             return ;
         }

         tx=a;
         ty=info[l].y;
         Solve(tx,ty,);

         tx=info[l].x;
         ty=b;
         Solve(tx,ty,);

         tx=;
         ty=info[l].y;
         Solve(tx,ty,);

         tx=info[l].x;
         ty=;
         Solve(tx,ty,);

         tx=info[l].x+min(a-info[l].x,info[l].y);
         ty=info[l].y-min(a-info[l].x,info[l].y);
         Solve(tx,ty,);

         tx=info[l].x-min(b-info[l].y,info[l].x);
         ty=info[l].y+min(b-info[l].y,info[l].x);
         Solve(tx,ty,);

         l++;
     }
     if(l>=r)
         printf("impossible\n");
 }

 int main(){

     //freopen("input.txt","r",stdin);

     while(~scanf("%d%d%d",&a,&b,&c)){
         memset(vis,,sizeof(vis));
         BFS();
     }
     return ;
 }