LOJ #6009 「网络流 24 题」软件补丁

题面

某公司发现其研制的一个软件中有 $ n $ 个错误，随即为该软件发放了一批共 $ m $ 个补丁程序。每一个补丁程序都有其特定的适用环境，某个补丁只有在软件中包含某些错误而同时又不包含另一些错误时才可以使用。一个补丁在排除某些错误的同时，往往会加入另一些错误。

换句话说，对于每一个补丁 $ i $，都有 $ 2 $ 个与之相应的错误集合 $ B_1(i) $ 和 $ B_2(i) $，使得仅当软件包含 $ B_1(i) $ 中的所有错误，而不包含 $ B_2(i) $ 中的任何错误时，才可以使用补丁 $ i $。补丁 $ i $ 将修复软件中的某些错误 $ F_1(i) $，而同时加入另一些错误 $ F_2(i) $。另外，每个补丁都耗费一定的时间。

试设计一个算法，利用公司提供的 $ m $ 个补丁程序将原软件修复成一个没有错误的软件，并使修复后的软件耗时最少。

输入格式

文件第 $ 1 $ 行有 $ 2 $ 个正整数 $ n $ 和 $ m \(，\) n $ 表示错误总数，$ m $ 表示补丁总数。接下来 $ m $ 行给出了 $ m $ 个补丁的信息。每行包括一个正整数，表示运行补丁程序 $ i $ 所需时间，以及 $ 2 $ 个长度为 $ n $ 的字符串，中间用一个空格符隔开。

第 $ 1 $ 个字符串中，如果第 $ k $ 个字符 $ b_k $ 为 +，则表示第 $ k $ 个错误属于 $ B_1(i) $。若为 -，则表示第 $ k $ 个错误属于 $ B_2(i) $，若为 0，则第 $ k $ 个错误既不属于 $ B_1(i) $ 也不属于 $ B_2(i) $，即软件中是否包含第 $ k $ 个错误并不影响补丁 $ i $ 的可用性。
第 $ 2 $ 个字符串中，如果第 $ k $ 个字符 $ b_k $ 为 -，则表示第 $ k $ 个错误属于 $ F_1(i) $，若为 +，则表示第 $ k $ 个错误属于 $ F_2(i) $，若为 0，则第 $ k $ 个错误既不属于 $ F_1(i) $ 也不属于 $ F_2(i) $，即软件中是否包含第 $ k $ 个错误不会因使用补丁 $ i $ 而改变。

输出格式

输出最小耗时，如果问题无解，则输出 $ 0 $。

思路

状压。由于 \(n\le20\) 且对于一个 bug 只有修复了和没修复两种状态，所以显然我们可以丢到 int 里面转移。

那么考虑对于一个补丁对应的两个集合中的 bug 该如何处理。我们假设不管是修复 bug 还是添加 bug 的集合 set 的 bug 都是 1，显然我们可以用 | set 来增加 set 里的 bug，用 & (~set) 来修复 set 里的 bug（很容易理解吧，直接 | 显然就加上了 bug，& 一个 0 显然是修了 bug 对不对）。

考虑到直接建图有 \(2^{20}\) 种状态，我们显然不能先建图然后枚举状态连边。我们可以不建图直接跑 SPFA，转移的时候判断一下合不合法就行了（类似 BFS？）。也很简单，就是将两个条件集合分别与当前状态 & 一下看看是否是两个条件集合就行了。边权是应用补丁的时间。

然后就是从全为 1 的状态出发跑一个 SPFA，答案就是到 0 的最短路。

#include <algorithm>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
const int M = 105;
const int N = 25;
#define INF 0x3f3f3f3f
int n, m, a[M], b[M], c[M], dp[1 << (N - 2)], mask_have[M], mask_not[M];
int vis[1 << (N - 2)], kill[M], bring[M];
char s1[M][N], s2[M][N];
typedef pair<int, int> P;
queue<P> G;
inline void init(int x) {
  for(register int i = n - 1; i >= 0; --i) {
    switch(s1[x][i]) {
      case '+': mask_have[x] |= 1 << i; break;
      case '-': mask_not[x] |= 1 << i; break;
    }
    switch(s2[x][i]) {
      case '+': bring[x] |= 1 << i; break;
      case '-': kill[x] |= 1 << i; break;
    }
  }
}
int main() {
  scanf("%d%d", &n, &m);
  memset(b, 0, sizeof b);
  memset(c, 0, sizeof c);
  for(register int i = 1; i <= m; ++i)
    scanf("%d%s%s", a + i, s1[i], s2[i]), init(i);
  memset(dp, INF, sizeof dp);
  dp[(1 << n) - 1] = 0;
  vis[(1 << n) - 1] = 1;
  G.push(P((1 << n) - 1, 0));
  while(!G.empty()) {
    P now = G.front(); G.pop();
    int stand = now.first; vis[stand] = 0;
    for(register int i = 1; i <= m; ++i) {
      if((mask_not[i] & (~stand)) != mask_not[i]) continue;
      if((mask_have[i] & stand) != mask_have[i]) continue;
      int to = (stand & (~kill[i])) | bring[i];
      if(dp[to] <= dp[stand] + a[i]) continue;
      dp[to] = dp[stand] + a[i];
      if(!vis[to]) vis[to] = true, G.push(P(to, dp[to]));
    }
  }
  printf("%d\n", dp[0] == INF ? 0 : dp[0]);
  return 0;
}