[BFS] ZOJ1005/POJ1606

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5

两个瓶子A B

给你三个数——分别是A的容量CA，B的容量CB，以及期望B瓶子里最后剩余的水的多少N

CA和CB互质，N介于两数之间，保证一定存在解

六种操作: fill A, fill B, empty A, empty B, pour B A, pour A  B

如果B 往 A 倒水，直到B空或者A满则停止

求最小次数及其步骤

一开始没用数组把节点存起来，只用了指针，最后全丢了没法打印

没判断当前情况是否出现过并优化，数组就不够大了

#include <cstring>
#include <iostream>
#include <queue>
#include <stdio.h>

using namespace std;

int CA, CB, N;

typedef struct node {
        int a, b, opt; // a,b,操作
        int pre, id;   //上一个和这个节点在数组内的位置
} Node;

Node arr[ 1000000 ];        //用于储存所有的节点的数组
bool visit[ 1001 ][ 1001 ]; //优化

int min ( int a, int b ) { return a > b ? b : a; }

Node newnode ( int a, int b, int p = 0, int o = 0, int d = 0 ) {
        Node tmp;
        tmp.a = a;
        tmp.b = b;
        tmp.opt = o;
        tmp.pre = p;
        tmp.id = d;
        return tmp;
}

bool success ( Node *tmp ) { //终止条件
        if ( tmp->b == N )
                return true;
        return false;
}

char option[ 7 ][ 10 ] = {"0", "fill A", "fill B", "empty A", "empty B", "pour B A", "pour A B"};

void print ( Node *f ) {
        if ( f->opt == 0 )
                return;
        print ( &arr[ f->pre ] );
        printf ( "%s\n", option[ f->opt ] ); //打印
}

Node bfs () {
        Node cur = newnode ( 0, 0 ); //第0个节点
        int prev, idx;
        prev = idx = 0; //记录cur节点在数组位置，记录当前数组的末尾

        queue<Node> Q;
        Q.push ( cur );
        arr[ prev ] = cur;

        while ( !success ( &cur ) ) {

                cur = Q.front ();
                Q.pop ();
                prev = cur.id;

                if ( cur.a != CA ) // fill A
                {
                        Node c = newnode ( CA, cur.b, prev, 1, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }

                if ( cur.b != CB ) // fill B
                {
                        Node c = newnode ( cur.a, CB, prev, 2, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }

                if ( cur.a != 0 ) // empty A
                {
                        Node c = newnode ( 0, cur.b, prev, 3, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }

                if ( cur.b != 0 ) // empty B
                {
                        Node c = newnode ( cur.a, 0, prev, 4, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }

                if ( cur.a != CA ) // pour B A
                {
                        int x = min ( CA - cur.a, cur.b );
                        Node c = newnode ( cur.a + x, cur.b - x, prev, 5, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }

                if ( cur.b != CB ) // pour A B
                {
                        int x = min ( CB - cur.b, cur.a );
                        Node c = newnode ( cur.a - x, cur.b + x, prev, 6, ++idx );
                        if ( !visit[ c.a ][ c.b ] ) {
                                arr[ idx ] = c;
                                visit[ c.a ][ c.b ] = 1;
                                Q.push ( c );
                        }
                }
        }
        return cur;
}

int main () {
        while ( cin >> CA >> CB >> N ) {
                memset ( visit, 0, sizeof ( visit ) );
                Node final = bfs ();
                print ( &final );
                printf ( "success\n" );
        }
        return 0;
}

依旧不带脑子啊hhhh以后还是要想清楚在写hhh要不不是给自己找罪受吗hhhh

参考http://blog.csdn.net/northsnow_bupt/article/details/21052979