bfs加上回溯

注意要儲存每一個節點

一開始只建了兩個節點就回溯不能了，還得全改成指標非常麻煩

再就是因為優先佇列的問題debug了很久，拿指標簡直是災難hhh

開始寫的Node優先順序比較的函式對指標不適用，改成普通的queue就好了

～～～

不是抄別人的程式碼太好了hhh

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

#define N 1000

using namespace std;

struct Node {
        int a, b;
        int cnt;
        int pre_oper;

        Node *prenode;

        //介個沒有用。。。
        // bool operator< ( const Node t ) const { return cnt > t.cnt; }

        Node () {
                a = b = cnt = pre_oper = 0;
                prenode = NULL;
        }

        Node ( const Node *t ) {
                a = t->a;
                b = t->b;
                cnt = t->cnt;
                pre_oper = t->pre_oper;
                prenode = t->prenode;
        }
} * log;

int sa, sb, required;
bool visit[ N ][ N ];

void operate ( Node *cur, Node *nex, int i ) {
        switch ( i ) {
        case 1: {
                nex->a = sa;
                break;
        }
        case 2: {
                nex->b = sb;
                break;
        }
        case 3: {
                nex->a = 0;
                break;
        }
        case 4: {
                nex->b = 0;
                break;
        }
        case 5: {
                nex->a = min ( sa, cur->a + cur->b );
                nex->b = cur->b - ( nex->a - cur->a );
                break;
        }
        case 6: {
                nex->b = min ( sb, cur->b + cur->a );
                nex->a = cur->a - ( nex->b - cur->b );
                break;
        }
        }
}

int bfs () {
        Node *c = new Node ();
        memset ( visit, false, sizeof ( visit ) );
        visit[ 0 ][ 0 ] = true;

        queue<Node *> q;
        q.push ( c );

        while ( !q.empty () ) {
                Node *cur = q.front ();
                q.pop ();

                if ( cur->a == required || cur->b == required ) {
                        log = cur;
                        return cur->cnt;
                }

                for ( int i = 1; i <= 6; ++i ) {
                        //要儲存每一個節點
                        Node *nex = new Node ( cur );
                        operate ( cur, nex, i );
                        nex->cnt = cur->cnt + 1;
                        nex->pre_oper = i;
                        nex->prenode = cur;

                        if ( !visit[ nex->a ][ nex->b ] ) {
                                visit[ nex->a ][ nex->b ] = true;
                                q.push ( nex );
                        }
                }
        }
        return -1;
}

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

void output ( Node *c ) {
        if ( c->pre_oper == 0 ) {
                return;
        }
        output ( c->prenode );
        cout << opt[ c->pre_oper ] << endl;
}

int main () {
        while ( cin >> sa >> sb >> required ) {
                int sol = bfs ();
                if ( sol == -1 )
                        cout << "impossible" << endl;
                else {
                        cout << sol << endl;
                        output ( log );
                }
        }
        return 0;
}