codevs2218 补丁VS错误（状压+spfa更新）

题目描述

错误就是人们所说的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：
3 3
1 000 00-
1 00- 0-+
2 0– -++
输出样例#1：
8

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

思路：就是正常的状压。开一个结构体分别记录下四种情况。然后搜索更新求最短路。之所以用最短路，而不是开一个结构体记录step，是因为有大有小。无法保证第一次搜到的比后面搜到的优。题目状态是从全1搜到全0。

代码如下：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=200005;
struct dqs
{
    int fz,ff,bz,bf,tim;
}hh[maxn];
int n,m,ans;
char shu[maxn];
queue<int>q;
int d[maxn];
bool used[maxn];
void bfs(int s)
{
    memset(d,63,sizeof(d));
    d[s]=0;
    q.push(s);
    used[s]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        used[x]=0;
        for(int i=1;i<=m;i++)
        {
            int tmp=x;
            bool flag=0;
            for(int j=1;j<=n;j++)
            {
                if(((hh[i].bz&(1<<j))&&!(tmp&(1<<j)))||((hh[i].bf&(1<<j))&&(tmp&(1<<j))))//软件没有包含Bi+中的所有错误或者说存在Bi-中的错误时
                {
                    flag=1;//不合法，不更新
                    break;
                }
            }
            if(!flag)//合法后删减
            {
                for(int j=1;j<=n;j++)
                {
                    if((hh[i].ff&(1<<j))&&(tmp&(1<<j)))
                        tmp-=(1<<j);
                    if((hh[i].fz&(1<<j))&&!(tmp&(1<<j)))
                        tmp+=(1<<j);        
                }
                if(d[tmp]>d[x]+hh[i].tim)
                {
                    d[tmp]=d[x]+hh[i].tim;
                    if(!used[tmp])
                    {
                        q.push(tmp);
                        used[tmp]=1;
                    }
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&hh[i].tim);
        scanf("%s",shu+1);
        for(int j=1;j<=n;j++)
        {
            if(shu[j]=='+') hh[i].bz+=(1<<j);
            if(shu[j]=='-') hh[i].bf+=(1<<j);           
        }
        scanf("%s",shu+1);
        for(int j=1;j<=n;j++)
        {   
            if(shu[j]=='+') hh[i].fz+=(1<<j);
            if(shu[j]=='-') hh[i].ff+=(1<<j);
        }
    }
    int sta=0;
    for(int i=1;i<=n;i++)   sta+=1<<i;
    bfs(sta);
    if(d[0]>10000000) puts("0");
    else printf("%d\n",d[0]);
    return 0;
}