codevs 2218 补丁 vs 错误 （最短路）

*PS：我为什么要打二进制啊QAQ

go to the problem

题目描述 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很小，可以用二进制压位来存状态。

把状态看做点，从S（n位每位都为1）到T（n位每位都为0）跑一边最短路。

代码

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
using namespace std;
const int Cn=525000;

int N,M,S,T,can;
int used[Cn],de[Cn];
char s[25];
struct maple{
    int t,B1,B2,F1,F2; // 1-> +  、 2->-
}Buding[210];

queue<int>q;

bool Can(int a,int n)
{
    if(Buding[n].B1)  // 判断是否包含B+中所有错误
        if(a-Buding[n].B1!=(a&(~Buding[n].B1))) return false;   
    if(Buding[n].B2)  // 判断是否不含B-中所有错误
        if(a&Buding[n].B2) return false;   
    return true;
}
int Do(int a,int n)
{
    a|=Buding[n].F1;  //加入F+中所有错误
    a&=(~Buding[n].F2);  //除去F-中所有错误
    return a;
}
void SPFA()
{
    memset(de,63,sizeof(de));
    used[S]=1;
    q.push(S);
    de[S]=0;
    while(!q.empty())
    {
        int a=q.front();
        q.pop();
        used[a]=0;
        for(int i=1;i<=M;++i)
           if(Can(a,i))
           {
               int k=Do(a,i); 
               if(de[k]>de[a]+Buding[i].t)
               {
                   de[k]=de[a]+Buding[i].t;
                   if(!used[k])
                   {
                       used[k]=1;
                       q.push(k);
                   }
                   if(!k) can=1;  //是否有解
               }
           }
    }
}
int main()
{
    scanf("%d%d",&N,&M);
    for(int j=1;j<=M;++j)
    {
        scanf("%d",&Buding[j].t);
        scanf("%s",s);
        for(int i=0;i<N;++i)
           if(s[i]!='0')
           {
               if(s[i]=='+') Buding[j].B1+=(1<<(N-i-1));
               else Buding[j].B2+=(1<<(N-i-1)); 
           }
        scanf("%s",s);
        for(int i=0;i<N;++i)
           if(s[i]!='0')
           {
               if(s[i]=='+') Buding[j].F1+=(1<<(N-i-1));
               else Buding[j].F2+=(1<<(N-i-1)); 
           }
    }
    for(int i=0;i<N;++i) S+=(1<<i);
    SPFA();
    if(can) printf("%d",de[0]);
    else printf("0");
    return 0;
} 

emmmm…调试时打的输出二进制的代码也放上吧…

void print(int n)
{
    if(!n)
    {
        printf("0\n");
        return ;
    }
    int f=0;
    for(int i=20;i>=0;--i)
      if(f||n&(1<<i))
      {
         f=1;
          if(n&(1<<i))  cout<<i<<' ';//cout<<1;
         //else cout<<0;
      }
    cout<<'\n';
}