POJ 2908 Quantum（BFS + 优先队列）

题意：

初始串经过一系列操作可以变换成目标串，每一次操作需要耗费一定的能量，求最小的能量。

思路：

1. 这一题同样采取 BFS 但是求的结果并不是最短路径，而是最小的耗能。其实也就是变换下思路，每次深搜之后把耗能最小的先出队列即可;

2. 这样的话可以把题目转换成优先队列的 dijstra 算法, 从源点到目标点的距离 -> 这里的点的变换即是状态的变换;

3. 题目中有个小 trick 使得一般的优先队列 BFS 算法无效，考虑如下 case:

   FFFF 10 , FFNN 1 , NNFF 1 , 0000 -> 1111 显然最小功耗是 2 而非 10，所以采用 dijstra 算法是合适的。

4. 由于题目中 L <= 20，所以在本题采用位运算会使过程变得十分优美，最终代码跑到了 141ms ;

 

#include <iostream>

#include <algorithm>

#include <queue>

using namespace std;



struct ST {

    int state, cost;

    ST(int _state, int _cost) : state(_state), cost(_cost) {}

    bool operator < (const ST& other) const { return cost > other.cost; }

};



struct OP {

    int op_and, op_or, op_xor;

    int cost;

} op[40];



const int INFS = 0x3fffffff;

int L, N, M, dis[1<<20];

bool vis[1<<20];



int bfs(int s, int t) {

    priority_queue<ST> Q;

    Q.push(ST(s, 0));



    for (int i = 0; i < 1<<L; i++)

        dis[i] = INFS, vis[i] = false;

    dis[s] = 0;



    while (!Q.empty()) {

        ST u = Q.top();

        Q.pop();



        if (u.state == t) 

            return u.cost;

        vis[s] = true;



        for (int i = 0; i < N; i++) {

            int v = u.state;

            v &= op[i].op_and;

            v |= op[i].op_or;

            v ^= op[i].op_xor;

            if (!vis[v] && dis[v] > u.cost + op[i].cost) {

                dis[v] = u.cost + op[i].cost;

                Q.push(ST(v, dis[v]));

            }

        }

    }

    return -1;

}



int main() {

    int cases;

    scanf("%d", &cases);

    while (cases--) {

        scanf("%d%d%d", &L, &N, &M);

        for (int i = 0; i < N; i++) {

            char s[30];

            scanf("%s%d", s, &op[i].cost);

            op[i].op_and = op[i].op_or = op[i].op_xor = 0;

            for (int j = 0; s[j]; j++) {

                op[i].op_and <<= 1;

                op[i].op_or <<= 1;

                op[i].op_xor <<= 1;

                if (s[j] == 'N') 

                    op[i].op_or |= 0;

                else if (s[j] == 'C') 

                    op[i].op_and |= 1;

                else if (s[j] == 'F')

                    op[i].op_xor |= 1;

                else if (s[j] == 'S')

                    op[i].op_or |= 1;

            }

            op[i].op_and = ~op[i].op_and;

        }

        for (int i = 0; i < M; i++) {

            char src[30], dst[30];

            int u = 0, v = 0;

            scanf("%s%s", src, dst);

            for (int j = 0; src[j]; j++)

                u <<= 1, u |= (src[j] - '0');

            for (int j = 0; dst[j]; j++)

                v <<= 1, v |= (dst[j] - '0');

            int ans = bfs(u, v);

            if (ans != -1) 

                printf("%d", ans);

            else 

                printf("NP");

            printf("%c", i == M-1 ? '\n' : ' ');

        }

    }

    return 0;

}