POJ2724 Purifying Machine

嘟嘟嘟


扒下来的题意：迈克有一台可以净化奶酪的机器，用二进制表示净化的奶酪的编号。但是，在某些二进制串中可能包含有\(*\)。例如\(01*100\)，\(*\)其实就代表可以取\(0\),\(1\)两种情况：\(010100\) 和\(011100\)。现在由于迈克不小心，他以同样的方式弄脏了某些奶酪，问你最少用多少次操作就可以把弄脏的奶酪全净化好。（没有被弄脏过的奶酪不能净化。弄脏过的奶酪可以多次净化。）
也就是给你一些不同的(判重之后)二进制串,每个串可以通过1次操作净化,也可以把两个只有1位不同的串通过1次操作联合净化.要我们求最少的操作次数.


嗯，首先把字符串转化成数，然后排序判重（用\(unique\)）。
对于二进制只有一位不同的两个数之间连一条边，表示可以联合净化。因此我们需要使联合净化的次数最多，所以就是求二分图的最大匹配数（因为每一个数只能净化一次）\(x\)。则答案就是数的总数 \(-x\)。
因为连边的时候是双向的，所以应该是总数 \(-x / 2\)

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 3e3 + 5;
const int maxe = 1e7 + 5;
const int N = 2050;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n, m, num[maxn];
char s[55];

struct Edge
{
  int nxt, to;
}e[maxe];
int head[maxn], ecnt = -1;
void addEdge(int x, int y)
{
  e[++ecnt] = (Edge){head[x], y};
  head[x] = ecnt;
}

int fa[maxn], vis[maxn], vcnt = 0;
bool dfs(int now)
{
  for(int i = head[now], v; i != -1; i = e[i].nxt)
    {
      if(vis[v = e[i].to] != vcnt)
    {
      vis[v] = vcnt;
      if(fa[v] == -1 || dfs(fa[v])) {fa[v] = now; return 1;}
    }
    }
  return 0;
}
int hung()
{
  int ret = 0;
  for(int i = 0; i < N; ++i)
    {
      vcnt++;
      if(dfs(i)) ret++;
    }
  return ret;
}

void init()
{
  Mem(num, 0);
  Mem(head, -1); ecnt = -1;
  Mem(fa, -1); Mem(vis, 0); vcnt = 0;
}

int main()
{
  while(scanf("%d%d", &n, &m) && (n + m))
    {
      init();
      int len = 0;
      for(int i = 1; i <= m; ++i)
    {
      len++;
      scanf("%s", s);
      int flg = -1;
      for(int j = 0; j < n; ++j)
        {
          if(s[j] == '*') flg = j;
          else num[len] |= (s[j] - '0') << j;
        }
      if(flg != -1) len++, num[len] = num[len - 1] | (1 << flg);
    }
      sort(num + 1, num + len + 1);
      int Len = unique(num + 1, num + len + 1) - num - 1;
      for(int i = 1; i <= Len; ++i)
    for(int j = 1; j <= Len; ++j)
      {
        int c = num[i] ^ num[j];
        if(c && !(c & (c -1))) addEdge(num[i], num[j]);
      }
      write(Len - (hung() >> 1)), enter;
    }
  return 0;
}