codevs2218 补丁vs错误 1999年CTSC国家队选拔赛[三星]

题目链接：戳我~
同类题目：建议独立完成~

题目描述 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个补丁，补丁必须在一定条件下在可以使用，即在第一个字符串中标注为’+’的地方的那个BUG必须存在，’-‘的地方的BUG必须没有；然后满足条件的补丁如果被打上，那么在第二个字符串中’+’的地方的BUG会出现，如果本来就有那无影响，’-‘的地方的BUG会消失，本来就没有那就不管，求最小补丁数来消除所有BUG。

看到题目的数据范围，很小，可以状压，压成二进制位。
那么我们就可以吧初始状态表示成二进制位为n位，并且全是1，那么目标状态就是二进制位为n位，全部是0.然后我们用spfa来求最短路径。

这里恶心的地方就是判断部分：
首先是判断这个补丁能不能用：

//结构体以及参数含义在下面完整版代码里有讲，这里简单讲一下
//  n1 满足有的BUG n2 满足没有的BUG n3 加上的bug n4 修复的bug 
flag = 0;
for(int j = 1;j <= n;j ++)
{
    if(num[i].n1 & (1 << j-1))
    {
        if((tmp & (1 << j-1)) == 0)//如果n1序列中第j-1位为1并且当前序列中第j-1位不是1，这样的序列是不满足条件的，必须存在的BUG并没有存在；
        {
            flag = 1;
            break;
        }
    }
}
if(flag == 1)   continue;
for(int j = 1;j <= n;j ++)
{
    if(num[i].n2 & (1 << j-1))
    {
        if((tmp & (1 << j-1)))//如果n1序列中第j-1位为1并且当前序列中第j-1位是1，这样的序列是不满足条件的，必须不存在的BUG存在；
        {
            flag = 1;
            break;
        }
    }
}

处理：

for(int j = 1;j <= n;j ++)
{
    if(num[i].n4 & (1 << j-1))
    {
        if((tmp & (1 << j-1)))//如果n4第j-1位为1，这说明这个BUG被修复了，如果当前序列有这个BUG，就修复它，没有，就不修复；
        {
            tmp -= (1 << j-1);
        }
    }
}
for(int j = 1;j <= n;j ++)
{
    if(num[i].n3 & (1 << j-1))
    {
        if((tmp & (1 << j-1)) == 0)//如果n3第j-1位为1，这说明这个BUG被加上了，如果当前序列没有这个BUG，就加上它，有，就不加；
        {
            tmp += (1 << j-1);
        }
    }
}

其他部分是spfa正常化~
下面附上完整代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<deque>
using namespace std;
const int INF = 2147483640;
string Commemorate_A_Pi = "0";
int now;
int n,m;
struct mad{
    int tim,n1,n2,n3,n4,step;
}num[233];
bool vis[2097450];
int dist[2097450];
int tmp;
queue <int> q;
void bfs()
{
    memset(dist,63,sizeof(dist));
    q.push(now);
    vis[now] = 1;
    dist[now] = 0;
    while(!q.empty())
    {
        int f = q.front();
        q.pop();
        vis[f] = 0;
        for(int i = 1;i <= m;i ++)
        {
            tmp = f;
            bool flag = 0;

            for(int j = 1;j <= n;j ++)
            {
                if(num[i].n1 & (1 << j-1))
                {
                    if((tmp & (1 << j-1)) == 0)
                    {
                        flag = 1;
                        break;
                    }
                }
            }
            if(flag == 1)   continue;
            for(int j = 1;j <= n;j ++)
            {
                if(num[i].n2 & (1 << j-1))
                {
                    if((tmp & (1 << j-1)))
                    {
                        flag = 1;
                        break;
                    }
                }
            }
            if(flag == 1)   continue;
            for(int j = 1;j <= n;j ++)
            {
                if(num[i].n4 & (1 << j-1))
                {
                    if((tmp & (1 << j-1)))
                    {
                        tmp -= (1 << j-1);
                    }
                }
            }
            for(int j = 1;j <= n;j ++)
            {
                if(num[i].n3 & (1 << j-1))
                {
                    if((tmp & (1 << j-1)) == 0)
                    {
                        tmp += (1 << j-1);
                    }
                }
            }
            if(dist[tmp] > dist[f] + num[i].tim)
            {
                dist[tmp] = dist[f] + num[i].tim;
                if(!vis[tmp])
                {
                    q.push(tmp);
                    vis[tmp] = 1;
                }

            }
        }
    }
}
//  n1 满足有的BUG n2 满足没有的BUG n3 加上的bug n4 修复的bug 
char c;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= m;i ++)
    {
        scanf("%d",&num[i].tim);
        for(int j = 1;j <= n;j ++)
        {
            cin>>c;
            if(c == '+')    num[i].n1 += (1 << j-1);
            if(c == '-')    num[i].n2 += (1 << j-1);
        }
        for(int j = 1;j <= n;j ++)
        {
            cin>>c;
            if(c == '+')    num[i].n3 += (1 << j-1);
            if(c == '-')    num[i].n4 += (1 << j-1);
        }
    }
    for(int i = 0;i < n;i ++)   now += (1 << i);
    bfs();
    if(dist[0] == 1061109567)   cout<<0;
    else    cout<<dist[0];
    return 0;
}
/*
7 15
1 0-00000 ---0--+
8 00000-0 0-++-00
6 000++00 ----0--
6 +00++00 ++-0--0
6 -000000 0+-000+
4 00-0+00 000--0-
4 00-00+0 ---0-00
6 00+0-+0 -0-0-00
9 000000+ 0+00-+0
10 00-0+00 -0-0+--
8 00+0-00 00000--
9 0000+00 +00+-++
2 -0--00- +-0-00-
1 0-00000 0--+00-
1 0000000 -0--0--

5

这组数据输出 5 请自行测试~
*/