POJ 3414 Pots（容量BFS）

Pots

 

大意：给你两个碗，三种操作，看多少步能凑出给你的容量。

思路：六入口的BFS，难点主要是在记录路径打印上，只要再开一个数组，记录一下前驱，最后按顺序打印即可。

 

 

#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;

int vis[110][110];
int a, b, c;

struct node
{
    int x, y, step;
} ;

struct Path
{
    int n, m, path;
} R[110][110];    ///保存前驱，方便打印

void output(int x, int y)
{
    stack<Path> p;
    while(!p.empty())
        p.pop();
    while(!(x == 0 && y == 0))
    {
        p.push(R[x][y]);
        int n_x = R[x][y].n;
        int n_y = R[x][y].m;
        x = n_x;
        y = n_y;
    }
    while(!p.empty())
    {
        switch(p.top().path)
        {
            case 1:printf("FILL(1)
");break;
            case 2:printf("FILL(2)
");break;
            case 3:printf("DROP(1)
");break;
            case 4:printf("DROP(2)
");break;
            case 5:printf("POUR(1,2)
");break;
            case 6:printf("POUR(2,1)
");break;
        }
        p.pop();
    }
}

void BFS()
{
    queue<node>q;
    while(!q.empty())
        q.pop();
    q.push((node){0, 0, 0});
    vis[0][0] = 1;
    while(!q.empty())
    {
        node t = q.front();
        q.pop();
        if(t.x == c || t.y == c)
        {
            printf("%d
", t.step);
            output(t.x, t.y);
            return ;
        }
        if(t.x < a && !vis[a][t.y])
        {
            vis[a][t.y] = 1;
            q.push((node){a, t.y, t.step+1});
            R[a][t.y] = (Path){t.x, t.y, 1};
        }
        if(t.y < b && !vis[t.x][b])
        {
            vis[t.x][b] = 1;
            q.push((node){t.x, b, t.step+1});
            R[t.x][b] = (Path){t.x, t.y, 2};
        }
        if(t.x > 0 && !vis[0][t.y])
        {
            vis[0][t.y] = 1;
            q.push((node){0, t.y, t.step+1});
            R[0][t.y] = (Path){t.x, t.y, 3};
        }
        if(t.y > 0 && !vis[t.x][0])
        {
            vis[t.x][0] = 1;
            q.push((node){t.x, 0, t.step+1});
            R[t.x][0] = (Path){t.x, t.y, 4};
        }
        if(t.x > 0 && t.y < b)
        {
            int k = min(t.x, b-t.y);
            if(!vis[t.x-k][t.y+k])
            {
                vis[t.x-k][t.y+k] = 1;
                q.push((node){t.x-k, t.y+k, t.step+1});
                R[t.x-k][t.y+k] = (Path){t.x, t.y, 5};
            }
        }
        if(t.x < a && t.y > 0)
        {
            int k = min(a-t.x, t.y);
            if(!vis[t.x+k][t.y-k])
            {
                vis[t.x+k][t.y-k] = 1;
                q.push((node){t.x+k, t.y-k, t.step+1});
                R[t.x+k][t.y-k] = (Path){t.x, t.y, 6};
            }
        }
    }
    printf("impossible
");
}

void Solve()
{
    scanf("%d%d%d", &a, &b, &c);
    BFS();
}

int main(void)
{
    Solve();

    return 0;
}