POJ 2908 Quantum (bfs+优先队列)

题意：给定m个操作和这几种操作所花费的能量，操作的长度n，如果源串能过经过这几种操作转化为目的串，问最多消耗多少能量。

思路：最短路径，也就是bfs+优先队列，不过在记录入队后的元素时要注意，进入队列的元素有可能在进入队列，因为多路径嘛，也就是说，根据最短路径的思想，要及时更新入队的元素，我用的是STL中的priority_queue来操作的，用堆应该快一些吧，记录状态的时候可以根据位运算来实现，减少内存和时间。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <cmath>
#include <set>
#include <queue>
#include <vector>
using namespace std;

const int BORDER = (1<<20)-1;
#define MAXN 50
#define INF 0x7ffffff
#define CLR(x,y) memset(x,y,sizeof(x))
#define ADD(x) ((++x)&BORDER)
#define IN(x) scanf("%d",&x)
#define OUT(x) printf("%d\n",x)
#define MIN(m,v) (m)<(v)?(m):(v)
#define MAX(m,v) (m)>(v)?(m):(v)
#define ABS(x) (x>0?x:-x)

struct NODE{
    int val;
    int step;
}node,t_node;
bool operator<(const NODE& a,const NODE& b)
{
    return a.step>b.step;
}
priority_queue<NODE> que;
int tt,n,m,n_word,mmin;
int dist[1<<22],op[MAXN][MAXN],cost[MAXN],origin[MAXN],target[MAXN];
int ans[MAXN];
int init()
{
    CLR(dist,127);
    CLR(origin,0);
    CLR(target,0);
    CLR(ans,-1);
    return 0;
}
int input()
{
    int i,j,tmp;
    char str[MAXN];
    scanf("%d%d%d",&n,&m,&n_word);
    for(i = 0; i < m; ++i)
    {
        scanf("%s %d",str,&cost[i]);
        for(j = 0; j < n; ++j)
        {
            switch(str[j])
            {
                case 'N': op[i][j] = 0; break;
                case 'F': op[i][j] = 1; break;
                case 'S': op[i][j] = 2; break;
                case 'C': op[i][j] = 4; break;
            }
        }
    }
    for(i = 0; i < n_word; ++i)
    {
        scanf("%s",str);
        for(j = 0; j < n; ++j)
            if(str[j] == '1')
                origin[i] |= (1<<n-j-1);
        scanf("%s",str);
        for(j = 0; j < n; ++j)
            if(str[j] == '1')
                target[i] |= (1<<n-j-1);
    }
    return 0;
}
int bfs(const int& index)
{
    int i,j,tmp,val,oper,k;
    /* empty the queue */
    while(!que.empty())
        que.pop();
    /* init queue */
    node.val = origin[index];
    node.step = 0;
    que.push(node);
    mmin = INF;
    /* while loop */
    while(!que.empty())
    {
        node = que.top();
        que.pop();
        val = node.val;
        if(val == target[index])
        {
            mmin = MIN(mmin,node.step);
            break;
        }
        for(i = 0; i < m; ++i)
        {
            tmp = val;
            for(j = 0; j < n; ++j)
            {
                oper = op[i][j];
                k = n-j-1;
                if(oper&1)
                    tmp = tmp^(1<<k);
                else if(oper&2)
                    tmp = tmp|(1<<k);
                else if(oper&4)
                    tmp = tmp&(~(1<<k));
            }
            if(dist[tmp] > node.step+cost[i])
            {
                dist[tmp] = node.step+cost[i];
                t_node.val = tmp;
                t_node.step = node.step+cost[i];
                que.push(t_node);
            }
        }
    }
    if(mmin != INF)
        ans[index] = mmin;
    return 0;
}
int output()
{
    int i,j,tmp;
    for(i = 0; i < n_word; ++i)
    {
        if(i == 0)
        {
            if(ans[0] == -1)
                printf("NP");
            else
                printf("%d",ans[0]);
            continue;
        }
        if(ans[i] == -1)
            printf(" NP");
        else
            printf(" %d",ans[i]);
    }
    printf("\n");
    return 0;
}

int main()
{
    int i,j,tmp;
    IN(tt);
    while(tt--)
    {
        init();
        input();
        for(i = 0; i < n_word; ++i)
        {
            CLR(dist,127);
            bfs(i);
        }
        output();
    }
    return 0;
}