Pots POJ - 3414

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)

题意

给你两个空杯子，告诉容量，问你能否用着来两个杯子弄出指定容量的水

思路

简单的bfs，难点是回溯，建议多看几篇题解学一下不同回溯方法

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <stack>
#include <cstdio>
using namespace std;
int a,b,c,top;
int vis[110][110];
struct node
{
    int x,y;//状态
    int w; //到达该状态的步骤
    int last;//上一个状态
    int step;//到达该状态需要几步
}ans[1000000];
void pri(int x) //六种方法打印
{
    if(x==0)
        printf("FILL(1)\n");
    if(x==1)
        printf("FILL(2)\n");
    if(x==2)
        printf("POUR(2,1)\n");
    if(x==3)
        printf("POUR(1,2)\n");
    if(x==4)
        printf("DROP(1)\n");
    if(x==5)
        printf("DROP(2)\n");
}
void yes(int x) //回溯
{
    if(ans[x].last==0)
    {
        pri(ans[x].w);
        return ;
    }
    yes(ans[x].last);
    pri(ans[x].w);
}
void bfs()
{
    int head,tail,i;
    int aa,bb;
    head = 0,tail = 1;
    while(head<=tail) //模拟队列
    {
        node x = ans[head++];
        if(x.x==c||x.y==c) //成功
        {
            cout<<ans[head-1].step<<endl;
            yes(head-1);
            return ;
        }
        for(i=0;i<6;i++) //六种操作
        {
            if(i==0)
            {
                aa = a;
                bb = x.y;
            }
            if(i==1)
            {
                aa = x.x;
                bb = b;
            }
            if(i==2)
            {
                aa = min(a,x.x+x.y);
                bb = max(0,x.y-(a-x.x));
            }
            if(i==3)
            {
                aa = max(0,x.x-(b-x.y));
                bb = min(b,x.x+x.y);
            }
            if(i==4)
            {
                aa = 0;
                bb = x.y;
            }
            if(i==5)
            {
                aa = x.x;
                bb = 0;
            }
            if(!vis[aa][bb])
            {
                ans[tail].x = aa;
                ans[tail].y = bb;
                ans[tail].w = i;
                ans[tail].step = x.step+1;
                ans[tail++].last = head-1;
                vis[aa][bb] = 1;
            }
        }
    }
    cout<<"impossible"<<endl;
}
int main()
{
    int i;
    while(cin>>a>>b>>c)
    {
        memset(vis,0,sizeof(vis));
        top = 0;
        ans[top].x = 0;
        ans[top].y = 0;
        ans[top].step = 0;
        ans[top++].last = 0; //初始状态为空
        vis[0][0] = 1;
        bfs();
    }
    return 0;
}