Vijos1019 补丁VS错误[最短路状态压缩]

描述

错误就是人们所说的Bug。用户在使用软件时总是希望其错误越少越好，最好是没有错误的。但是推出一个没有错误的软件几乎不可能，所以很多软件公司都在疯狂地发放补丁（有时这种补丁甚至是收费的）。T公司就是其中之一。

上个月，T公司推出了一个新的字处理软件，随后发放了一批补丁。最近T公司发现其发放的补丁有致命的问题，那就是一个补丁在排除某些错误的同时，往往会加入另一些错误.
此字处理软件中只可能出现n个特定的错误，这n个错误是由软件本身决定的。T公司目前共发放了m个补丁，对于每一个补丁, 都有特定的适用环境，某个补丁只有在当前软件中包含某些错误而同时又不包含另一些错误时才可以使用，如果它被使用，它将修复某些错误而同时加入某些错误。另外，使用每个补丁都要耗一定的时间（即补丁程序的运行时间）。

更准确地说明：
设此字处理软件中可能出现的n个错误为集合B={b1,b2,…,bn}中的元素，T公司目前共发放了m个补丁：p1，p2,…,pm。对于每一个补丁pi, 都有特定的适用环境，某个补丁只有在软件中包含某些错误而同时又不包含另一些错误时才可以用，为了说明清楚，设错误集合：Bi+、 Bi-，当软件包含了Bi+中的所有错误, 而没有包含Bi-中的任何错误时，补丁Pi才可以被使用，否则不能使用，显然 Bi+、Bi-交集为空。补丁pi将修复某些错误而同时加入某些错误，设错误集合Fi-、Fi+，使用过补丁pi之后，Fi-中的任何错误都不会在软件中出现，而软件将包含Fi+中的所有错误，同样Fi-、Fi+交集为空。另外，使用每个补丁都要耗一定的时间（即补丁程序的运行时间）。

现在T公司的问题很简单，其字处理软件的初始版本不幸地包含了集合B中的全部n个错误, 有没有可能通过使用这些补丁（任意顺序地使用，一个补丁可使用多次），使此字处理软件成为一个没有错误的软件。如果可能，希望找到总耗时最少的方案。

格式

输入格式

第一行有两个正整数n和m, n表示错误总数，m表示补丁总数，1<=n<=15, 1<=m<=100。接下来m行给出了m个补丁的信息。每行包括一个正整数（表示此补丁程序pi的运行耗时）和两个长度为n的字符串，中间用一个空格符隔开。

第一个字符串，如果第k个字符为’+’，则表示bk属于Bi+, 若为‘-’，则表示bk属于Bi-, 若为‘0’，则bk 既不属于Bi+也不属于Bi-，即软件中是否包含bk不影响补丁pi是否可用。

第二个字符串，如果第k个字符为’+’，则表示bk属于Fi+, 若为‘-’，则表示bk属于Fi-, 若为‘0’，则bk 既不属于Fi+也不属于Fi-，即软件中是否包含bk不会因使用补丁pi而改变。

输出格式

输出一个整数，如果问题有解，输出总耗时，否则输出0。

样例1

样例输入1[复制]

3 3
1 000 00-
1 00- 0-+
2 0-- -++

样例输出1[复制]

提示

注意，请按照n最大为15的条件编程；
如果空间占用过多，将提示答案错误，而不是运行时错误或者其他提示。

来源

Vivian Snow
CTSC99 Day1 ProblemB

二进制表示状态，可以转移就连一条边，求最短路

很像白书上那道题，不显式建边应该也可以

注意位运算

//
//  main.cpp
//  vijos
//
//  Created by Candy on 9/29/16.
//  Copyright © 2016 Candy. All rights reserved.
//

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
const int N=15,M=105,INF=1e9+5;

int n,m,p[M],bt[M],bf[M],ft[M],ff[M];
struct edge{
    int v,ne,w;
}e[M*(1<<N)];
int h[1<<N],cnt=0;
char s[N+5];
inline void ins(int u,int v,int w){
    cnt++;
    e[cnt].v=v;e[cnt].w=w;e[cnt].ne=h[u];h[u]=cnt;
}
void buildGraph(){
    for(int i=0;i<(1<<n);i++)
        for(int j=1;j<=m;j++){
            if((i&bt[j])==bt[j] && (i&bf[j])==0)
                ins(i,(i&(~ff[j]))|ft[j],p[j]);
        }
}

struct hn{
    int u;int d;
    bool operator <(const hn &rhs)const{return d>rhs.d;}
    hn(int a=0,int b=0):u(a),d(b){}
};
int d[1<<N]; bool done[1<<N];
void dijkstra(int S){
    memset(d,127,sizeof(d));
    priority_queue<hn> q;
    q.push(hn(S,0));
    d[S]=0;
    while(!q.empty()){
        hn x=q.top();q.pop();
        int u=x.u;
        if(done[u]) continue;
        done[u]=1;
        for(int i=h[u];i;i=e[i].ne){
            int v=e[i].v,w=e[i].w;
            if(d[v]>d[u]+w){
                d[v]=d[u]+w;
                q.push(hn(v,d[v]));
            }
        }
    }
}
int main(int argc, const char * argv[]) {
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%s",&p[i],s);
        for(int j=0;j<n;j++){
            if(s[j]=='+') bt[i]|=(1<<j);
            if(s[j]=='-') bf[i]|=(1<<j);
        }
        scanf("%s",s);
        for(int j=0;j<n;j++){
            if(s[j]=='+') ft[i]|=(1<<j);
            if(s[j]=='-') ff[i]|=(1<<j);
        }
    }
    buildGraph();
    dijkstra((1<<n)-1);
    if(d[0]>INF) printf("0");
    else printf("%d",d[0]);
    return 0;
}