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

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

題意簡述：

給出兩個壺的容量A和B, 一個目標水量C，對A、B可以有３種操作，求最少經過幾步操作能夠在某個壺中得到目標水量C。輸入A、B和C，輸入最少運算元和操作過程。

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 potj is full (and there may be some water left in the poti), or the poti is empty (and all its contents have been moved to the potj).

問題分析：

　　把A和B壺中水量作為狀態，初始狀態為<0,0>，每個操作都是狀態變化的過程。因為有２個壺，所以總共有６種操作。使用ＢＦＳ搜尋來找到最少的操作步數。同時需要考慮操作的條件，以減少操作來加快程式執行速度。

程式說明：

　　搜尋過的狀態就不需要再搜尋了，用陣列notvist[][]來標記搜尋過的狀態。操作的前提條件已經寫在程式中。

AC的C++語言程式如下：

/* POJ3414 Pots */

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

const int MAXN = 100;

int a, b, c;
bool notvist[MAXN+1][MAXN+1];

struct node {
    int a, b, level;
    char path[MAXN+1];
    int plen;
};

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

void output_result(int lvl, char p[], int n)
{
    cout << lvl << endl;
    for(int i=0; i<n; i++)
        cout << path[(int)p[i]] << endl;
}

void bfs()
{
    queue<node> q;

    memset(notvist, true, sizeof(notvist));

    node f;
    f.a = 0;
    f.b = 0;
    f.level = 0;
    memset(f.path, 0, sizeof(f.path));
    f.plen = 0;
    q.push(f);

    notvist[f.a][f.b] = false;

    while(!q.empty()) {
        f = q.front();
        q.pop();

        if(f.a == c || f.b == c) {
            output_result(f.level, f.path, f.plen);
            return;
        }

        node v;

        v = f;
        v.level++;
        v.plen++;
        // FILL(a)
        if(a - f.a > 0) {
            v.a = a;
            v.b = f.b;
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 0;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
        // FILL(b)
        if(b - f.b > 0) {
            v.a = f.a;
            v.b = b;
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 1;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
        // DROP(a)
        if(f.a) {
            v.a = 0;
            v.b = f.b;
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 2;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
        // DROP(b)
        if(f.b) {
            v.a = f.a;
            v.b = 0;
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 3;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
        // POUR(a,b)
        if(f.a && (f.b < b)) {
            if(f.a > (b - f.b)) {
                v.a = f.a -(b - f.b);
                v.b = b;
            } else {
                v.a = 0;
                v.b = f.b + f.a;
            }
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 4;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
        // POUR(b,a)
        if(f.b && (f.a < a)) {
            if(f.b > (a - f.a)) {
                v.a = a;
                v.b = f.b -(a - f.a);
            } else {
                v.a = f.a + f.b;
                v.b = 0;
            }
            if(notvist[v.a][v.b]) {
                v.path[f.plen] = 5;
                q.push(v);
                notvist[v.a][v.b] = false;
            }
        }
    }

    cout << "impossible" << endl;
}

int main()
{
    cin >> a >> b >> c;

    bfs();

    return 0;
}