P3355 骑士共存问题 （最大独立集）.md

P3355 骑士共存问题 （最大独立集）

题目链接： 骑士共存问题

题意

给你一个N * N的棋盘，你需要在里面放置尽可能多的骑士，（骑士走1 * 2）来使得任意两个骑士都无法消灭对方，并且有M个点已经被障碍物挡住了。

数据范围： $N<200;M<N^2$

---

思路

题目经过稍加分析可以知道，如果我们用白和黑两种颜色来将图染色，相邻不同色，那么易得，骑士能吃到的地方一定是不同颜色的，而图总共有两种颜色，所以如果两个点同色是不可能到达的。那么在最后得到的答案里，任意两个点都相邻。即变为了求二分图最大独立集的问题。

在一个二分图中，求最大独立集等价与总共的点减去最小割。那么建完图后跑个最大流就好了。

---

代码

#include <bits/stdc++.h>
using namespace std;
#define rep(i,j,k) for(int i = (int)j;i <= (int)k;i ++)
#define per(i,j,k) for(int i = (int)j;i >= (int)k;i --)
#define debug(x) cerr<<#x<<" = "<<(x)<<endl
#define mmm(a,b) memset(a,b,sizeof(a))
#define pb push_back

typedef double db;
typedef long long ll;
const int MAXN = (int)50000+7;
const int INF = (int)0x3f3f3f3f;

// 用于表示表示边的结构体（终点、容量、反向边）
struct edge{
    int to,cap,rev;
    edge(int to = 0,int cap = 0,int rev = 0):to(to),cap(cap),rev(rev){}
};

int N,M;
vector<edge> G[MAXN];
int level[MAXN]; //顶点到源点的距离标号
int iter[MAXN];  //当前弧，在其之前的边已经没有用了

//向图中增加一条从s到t容量为cap的边
void add_edge(int from,int to,int cap) {
    G[from].pb(edge(to,cap,G[to].size()));
    G[to  ].pb(edge(from,0,G[from].size()-1));
}

//通过BFS计算从源点出发的距离标号
void bfs(int s){
    mmm(level,-1);
    queue<int> qu;
    level[s] = 0;
    qu.push(s);
    while (!qu.empty()) {
        int v = qu.front(); qu.pop();
        rep(i,0,G[v].size()-1) {
            edge &e = G[v][i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                qu.push(e.to);
            }
        }
    }
}

//通过DFS寻找增广路
int dfs(int v,int t,int f) {
    if (v == t) return f;
    for (int &i = iter[v];i < G[v].size();i ++) {
        edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to,t,min(f,e.cap));
            if (d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

//求解从s到t的最大流
int max_flow(int s,int t){
    int flow = 0;
    for (;;) {
        bfs(s);
        if (level[t] < 0) return flow;
        mmm(iter,0);
        int f;
        while ((f = dfs(s,t,INF)) > 0)
            flow += f;
    }
}

void init(){
    rep(i,1,N) G[i].clear();
}

int nn,mm,s,t;
bool pic[210][210];
int dir[8][2] = {{1,2},{2,1},{-1,2},{-2,1},{1,-2},{2,-1},{-1,-2},{-2,-1} };

int main()
{
    scanf("%d %d",&nn,&mm);
    s = nn*nn+1;
    t = s + 1;
    N = t + 1;
	rep(i,1,mm) {
        int x,y;
        scanf("%d %d",&x,&y);
        pic[x][y] = 1;
	}int tot = 0;
	rep(i,1,nn) {
        rep(j,1,nn) {
            if (pic[i][j]) continue;
            if ((i+j)&1) {
                add_edge(s,i*nn-nn+j,1);
                rep(k,0,7) {
                    int dx = i+dir[k][0];
                    int dy = j+dir[k][1];
                    if (dx < 1 || dx > nn || dy < 1 || dy > nn || pic[dx][dy]) continue;
                    add_edge(i*nn-nn+j,dx*nn-nn+dy,INF);
                }
            }else {
                add_edge(i*nn-nn+j,t,1);
            }
        }
	}

	int ans = max_flow(s,t);
	printf("%d\n",nn*nn-mm-ans);
}