[luoguP3355] 骑士共存问题（二分图最大独立集）

传送门

模型

二分图最大独立集，转化为二分图最大匹配，从而用最大流解决。

实现

首先把棋盘黑白染色，使相邻格子颜色不同。

把所有可用的黑色格子看做二分图X集合中顶点，可用的白色格子看做Y集合顶点。

建立附加源S汇T，从S向X集合中每个顶点连接一条容量为1的有向边，从Y集合中每个顶点向T连接一条容量为1的有向边。

从每个可用的黑色格子向骑士一步能攻击到的可用的白色格子连接一条容量为无穷大的有向边。

求出网络最大流，要求的结果就是可用格子的数量减去最大流量。

分析

用网络流的方法解决棋盘上的问题，一般都要对棋盘黑白染色，使之成为一个二分图。放尽可能多的不能互相攻击的骑士，就是一个二分图最大独立集问题。有关二分图最大独立集问题，更多讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

该题规模比较大，需要用效率较高的网络最大流算法解决。（使用Dinic+当前弧优化）

——代码

 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #define INF 1e9
 #define N 1000001
 #define min(x, y) ((x) < (y) ? (x) : (y))
 
 int n, m, cnt, tot, sum, s, t;
 int map[][], head[N], to[N], val[N], next[N], dis[N], cur[N];
 int dx[] = {-, -, , , , , -, -},
     dy[] = {, , , , -, -, -, -};
 
 inline int read()
 {
     int x = , f = ;
     char ch = getchar();
     for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -;
     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';
     return x * f;
 }
 
 inline void add2(int x, int y, int z)
 {
     to[cnt] = y;
     val[cnt] = z;
     next[cnt] = head[x];
     head[x] = cnt++;
 }
 
 inline void add(int x, int y, int z)
 {
     add2(x, y, z);
     add2(y, x, );
 }
 
 inline bool bfs()
 {
     int i, u, v;
     std::queue <int> q;
     memset(dis, -, sizeof(dis));
     q.push(s);
     dis[s] = ;
     while(!q.empty())
     {
         u = q.front(), q.pop();
         for(i = head[u]; i ^ -; i = next[i])
         {
             v = to[i];
             if(val[i] && dis[v] == -)
             {
                 dis[v] = dis[u] + ;
                 if(v == t) return ;
                 q.push(v);
             }
         }
     }
     return ;
 }
 
 inline int dfs(int u, int maxflow)
 {
     if(u == t) return maxflow;
     int v, d, ret = ;
     for(int &i = cur[u]; i ^ -; i = next[i])
     {
         v = to[i];
         if(val[i] && dis[v] == dis[u] + )
         {
             d = dfs(v, min(val[i], maxflow - ret));
             ret += d;
             val[i] -= d;
             val[i ^ ] += d;
             if(ret == maxflow) return ret;
         }
     }
     return ret;
 }
 
 int main()
 {
     int i, j, k, x, y;
     n = read();
     m = read();
     s = , t = n * n + ;
     memset(head, -, sizeof(head));
     for(i = ; i <= m; i++)
     {
         x = read();
         y = read();
         map[x][y] = -;
     }
     for(i = ; i <= n; i++)
         for(j = ; j <= n; j++)
             if(!map[i][j])
             {
                 map[i][j] = ++tot;
                 if((i + j) & ) add(s, tot, );
                 else add(tot, t, );
             }
     for(i = ; i <= n; i++)
         for(j = ; j <= n; j++)
             if(map[i][j] ^ - && (i + j) & )
                 for(k = ; k < ; k++)
                 {
                     x = i + dx[k];
                     y = j + dy[k];
                     if(x >=  && x <= n && y >=  && y <= n && map[x][y] ^ -) add(map[i][j], map[x][y], INF);
                 }
     while(bfs())
     {
         for(i = s; i <= t; i++) cur[i] = head[i];
         sum += dfs(s, INF);
     }
     printf("%d\n", tot - sum);
     return ;
 }