POJ3414 Pots倒水问题

Pots
Time Limit: 1000MS        Memory Limit: 65536K
Total Submissions: 5822        Accepted: 2451        Special Judge

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
Northeastern Europe 2002, Western Subregion

依旧BFS（最近按照POJ训练计划做的所以BFS文章比较多……^_^）。

题目大意就是经典的倒水问题了，给你2个空瓶子，一个容量为A，另一个容量为B.

你可以进行下列3种操作：

1.把一个瓶子从水龙头装满水。

2.将一个瓶子里的水倒到另一个瓶子里（如果能倒满就必须倒满，不能洒水），可能会有剩余。

3.直接倒空一个瓶子（倒到垃圾堆^_^）。

最后输出最少步数及详细过程。

搜索时需要注意的点就是两个瓶子互倒的情况，需要分开处理倒水的瓶子有无剩余水。

我使用字符串类来存储过程信息，因此最后花费内存很大，可以用数组优化。

编译环境：Linux ubuntu 2.6.35-30-generic,g++ 4.4.5,KDevelop IDE

应用：STL queue标准队列。G++编译0MS 720K

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
using namespace std;
struct po
{
    long a,b,step;
    string mv;
    po()
    {
        mv="";
        step=0;
        a=0;
        b=0;
    }
};
bool been[101][101];
queue<po> q;
long A,B,C;
bool check(po x)
{
    if(x.a==C||x.b==C)
        return true;
    return false;
}
po bfs(po st)
{
    //printf("Start: A:%ld B:%ld C:%ld\n",st.a,st.b,C);
    q.push(st);
    po now,t;
    if(st.a==C||st.b==C)
        return st;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.a<A&& !been[A][now.b])    //装满a瓶
        {
            t=now;
            t.mv+="F1";
            t.a=A;
            t.step++;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
        if(now.b<B&& !been[now.a][B])    //装满B瓶
        {
            t=now;
            t.mv+="F2";
            t.b=B;
            t.step++;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
        //缺少了倒水的瓶子里剩余水的情况
        if(now.a<A&&now.b<=(A-now.a)&&now.b>0&& !been[now.a+now.b][0])
//b给a倒水，没有剩余
        {
            t=now;
            t.mv+="P21";
            t.step++;
            t.a+=t.b;
            t.b=0;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
        else    //注意只能嵌套一个if
            if(now.a<A&&now.b>(A-now.a)&& !been[A][now.b-(A-now.a)])        //b给a倒水，有剩余
            {
                t=now;
                t.mv+="P21";
                t.step++;
                t.b-=(A-t.a);
                t.a=A;
                been[t.a][t.b]=true;
                if(check(t))
                    return t;
                q.push(t);
            }
        if(now.b<B&&now.a<=(B-now.b)&&now.a>0&& !been[0][now.a+now.b])
//a给b倒水，无剩余
        {
            t=now;
            t.mv+="P12";
            t.step++;
            t.b+=t.a;
            t.a=0;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
        else
            if(now.b<B&&now.a>(B-now.b)&& !been[now.a-(B-now.b)][B])        //a倒给b，有剩余
            {
                t=now;
                t.mv+="P12";
                t.step++;
                t.a-=(B-t.b);
                t.b=B;
                been[t.a][t.b]=true;
                if(check(t))
                    return t;
                q.push(t);
            }
        //相互倒水完毕～
        if(now.a>0&& !been[0][now.b])    
        {
            t=now;
            t.mv+="D1";
            t.a=0;
            t.step++;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
        if(now.b>0&& !been[now.a][0])
        {
            t=now;
            t.mv+="D2";
            t.b=0;
            t.step++;
            been[t.a][t.b]=true;
            if(check(t))
                return t;
            q.push(t);
        }
    }
    po ans;
    ans.step=-1;
    return ans;
}
int main(void)
{
    scanf("%ld%ld%ld",&A,&B,&C);
    memset(been,false,sizeof(been));
    po start;
    start.a=start.b=start.step=0;
    po ans=bfs(start);
    if(ans.step==-1)
        printf("impossible\n");
    else
    {
        printf("%ld\n",ans.step);
        for(long i=0;i!=(long)ans.mv.size();i++)
        {
            if(ans.mv.at(i)=='F')
            {
                printf("FILL(");
                i++;
                printf("%c)\n",ans.mv.at(i));
            }
            else
                if(ans.mv.at(i)=='P')
                {
                    printf("POUR(");
                    i++;
                    printf("%c",ans.mv.at(i));
                    i++;
                    printf(",%c)\n",ans.mv.at(i));
                }
                else
                {
                    printf("DROP(");
                    i++;
                    printf("%c)\n",ans.mv.at(i));
                }
        }
    }
    return 0;
}