UVa 658

链接：

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=599

题意：

补丁在修正bug时，有时也会引入新的bug。假定有n（n≤20）个潜在bug和m（m≤100）个补丁，
每个补丁用两个长度为n的字符串表示，其中字符串的每个位置表示一个bug。
第一个串表示打补丁之前的状态（“-”表示该bug必须不存在，“+”表示必须存在，0表示无所谓），
第二个串表示打补丁之后的状态（“-”表示不存在，“+”表示存在，0表示不变）。
每个补丁都有一个执行时间，你的任务是用最少的时间把一个所有bug都存在的软件通过打补丁的方式变得没有bug。
一个补丁可以打多次。

分析：

在任意时刻，每个bug可能存在也可能不存在，所以可以用一个n位二进制串表示当前软件的“状态”。
打完补丁之后，bug状态会发生改变，对应“状态转移”。
把状态看成结点，状态转移看成边，转化成图论中的最短路径问题，然后使用Dijkstra算法求解。
不过这道题和普通的最短路径问题不一样：结点很多，多达2^n个，
而且很多状态根本遇不到（即不管怎么打补丁，也不可能打成那个状态），所以没有必要先把图储存好。
用隐式图搜索即可：当需要得到某个结点u出发的所有边时，直接枚举所有m个补丁，看看是否能打得上。

代码：

import java.io.*;
import java.util.*;
import static java.util.Arrays.*;

public class Main {
    Scanner cin = new Scanner(new BufferedInputStream(System.in));
    final int INF = 0x3f3f3f3f;
    final int UPN = 20;
    final int UPM = 100;
    int n, m, sec[] = new int[UPM], d[] = new int[1<<UPN];
    char before[][] = new char[UPM][UPN], after[][] = new char[UPM][UPN];
    boolean done[] = new boolean[1<<UPN];
    
    class Node implements Comparable<Node> {
        int s, dist;
        
        Node(int s, int dist) {
            this.s = s;
            this.dist = dist;
        }
        
        @Override
        public int compareTo(Node that) {
            return dist - that.dist;
        }
    }
    
    int dijkstra() {
        fill(d, INF);
        fill(done, false);
        int ori = (1<<n) - 1;
        PriorityQueue<Node> Q = new PriorityQueue<Node>();
        d[ori] = 0;
        Q.add(new Node(ori, 0));
        while(Q.size() > 0) {
            Node cur = Q.poll();
            if(cur.s == 0) return cur.dist;
            if(done[cur.s]) continue;
            done[cur.s] = true;
            for(int t = 0; t < m; t++) {
                boolean patchable = true;
                for(int i = 0; i < n; i++) {
                    if(before[t][i] == '+' && (cur.s&(1<<i)) == 0) { patchable = false; break; }
                    else if(before[t][i] == '-' && (cur.s&(1<<i)) > 0) { patchable = false; break; }
                }
                if(!patchable) continue;
                
                Node temp = new Node(cur.s, cur.dist + sec[t]);
                for(int i = 0; i < n; i++) {
                    if(after[t][i] == '+') temp.s |= (1<<i);
                    else if(after[t][i] == '-') temp.s &= ~(1<<i);
                }
                if(d[temp.s] > temp.dist) {
                    d[temp.s] = temp.dist;
                    Q.add(temp);
                }
            }
        }
        return -1;
    }
    
    void MAIN() {
        for(int cases = 1; ; cases++) {
            n = cin.nextInt();
            m = cin.nextInt();
            if(n + m == 0) break;
            for(int i = 0; i < m; i++) {
                sec[i] = cin.nextInt();
                before[i] = cin.next().toCharArray();
                after[i] = cin.next().toCharArray();
            }
            int ans = dijkstra();
            System.out.printf("Product %d
", cases);
            if(ans < 0) System.out.printf("Bugs cannot be fixed.

");
            else System.out.printf("Fastest sequence takes %d seconds.

", ans);
        }
    }
    
    public static void main(String args[]) { new Main().MAIN(); }
}