【CTSC1999】补丁vs错误 状压最短路

题目描述 Description

错误就是人们所说的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个错误, 有没有可能通过使用这些补丁（任意顺序地使用，一个补丁可使用多次）， 使此字处理软件成为一个没有错误的软件。如果可能，希望找到总耗时最少的方案。

输入描述 Input Description

输入文件第一行有两个正整数n和m, n表示错误总数，m表示补丁总数。接下来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而改变。

输出描述 Output Description

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

样例输入 Sample Input

3 3

1 000 00-

1 00- 0-+

2 0– -++

样例输出 Sample Output

8

数据范围及提示 Data Size & Hint

1<=n<=20, 1<=m<=100

题意比较难懂，我来解释一下。

你现在有一个中了n种bug的软件，还有m个补丁。
每个补丁有五个参数：
运行时间t。
决定这种补丁的运行环境。此补丁所运行在的软件必须包含所有B+个bug并且不包含另外B-个bug。
决定补丁造成的影响。使用后，此软件将修复所有F-个bug，但会加上所有F+个bug。
现在每个补丁都可以安装好多次，求最短运行时间。

建图跑最短路。把当前软件的bug感染情况和每个补丁的B+、B-、F+、F-压到二进制位里，则可以这样转移：

设u为当前状态。则须满足：

B+⊆ u && B-∩u==Ø

则可以转移到状态v：

v=u;
if(( (1<<j)&F- )&&( v&(1<<j) )) v^=(1<<j);
v|=F+;

这样就可以用u来更新v了。
起始状态：( (1<<n)-1 )
目标状态：0

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int size=1500010;
const int INF=233333333;
struct edge{
    int d;
    int b1,b2;
    int f1,f2;
}l[size];
int dist[size];
int n,m;

void print(int x)
{
    for(int i=10;i>=0;i--)
    {
        printf("%d",(x>>i)&1);
    }
}
queue<int> q;
bool use[size];
void spfa(int s)
{
    for(int i=0;i<=(1<<n)-1;i++) dist[i]=INF;
    dist[s]=0;
    q.push(s);
    use[s]=1;
    while(q.size())
    {
        int f=q.front(); q.pop();
        use[f]=0;
        for(int i=1;i<=m;i++)
        {
            if( ((l[i].b1&f)==l[i].b1) &&((l[i].b2&f)==0))
            {
                int x=f;
                for(int j=0;j<n;j++)
                {
                    if((1<<j)&l[i].f2&&(1<<j)&x) x^=(1<<j);
                }
                x|=l[i].f1;
                if(dist[x]>dist[f]+l[i].d)
                {
                    dist[x]=dist[f]+l[i].d;
                    if(!use[x])
                    {
                        use[x]=1;
                        q.push(x);
                    }
                }
            }
        }
    }
// for(int i=0;i<=(1<<n)-1;i++) {print(i);printf(" ");cout<<dist[i]<<endl;}
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&l[i].d);
        string b,f;
        cin>>b>>f;
        for(int j=0;j<n;j++)
        {
            if(b[j]=='+') l[i].b1|=(1<<j);
            if(b[j]=='-') l[i].b2|=(1<<j);
            if(f[j]=='+') l[i].f1|=(1<<j);
            if(f[j]=='-') l[i].f2|=(1<<j);          
        }
        //printf("%d %d %d %d\n",l[i].b1,l[i].b2,l[i].f1,l[i].f2); 
    }
    spfa((1<<n)-1);
    printf("%d",dist[0]==INF?0:dist[0]);
    return 0;
}