P3355 骑士共存问题【最小点覆盖】【网络流24题】

思路

　　显然棋盘上的每个点有三种形态：障碍物，马，已存的马能跳到的不能放马的点

　　显然1、3在处理时可以归为一类，则共有两种点态。

　　所以这题可以看成一个二分图来做

　　每个马最多能覆盖棋盘上的八个点位

　　这就形似最大独立集的概念了

　　把所有独立集和障碍物都染色，剩下的就是就是可以放马的点

CODE

#include <bits/stdc++.h>

using namespace std;



const int maxn = 1e6 + 7;

const int inf = 0x3f3f3f3f;



template<class T>inline void read(T &res)

{

    char c;T flag=1;

    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';

    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;

}



struct edge{int from,to,cap,flow;};

int s, t, n, m;

struct isap

{

    int n,s,t,p[maxn],d[maxn],cur[maxn],num[maxn];

    bool vis[maxn];

    vector<int>g[maxn];

    vector<edge>edges;

    void init(int n,int s,int t) {

        this->n = n;

        this->s = s;

        this->t = t;

        for(int i = 1;i <= n;i++) g[i].clear();

        edges.clear();

    }

    void addegde(int from,int to,int cap) {

        edges.push_back((edge){from, to, cap, 0});

        edges.push_back((edge){to, from, 0, 0});

        int m = edges.size();

        g[from].push_back(m-2);

        g[to].push_back(m-1);

    }



    int augment() {///找增广路

        int x = t,a = inf;

        while(x!=s) {

            a = min(a, edges[p[x]].cap - edges[p[x]].flow);

            x = edges[p[x]].from;

        }

        x=t;

        while(x != s) {

            edges[p[x]].flow += a;

            edges[p[x]^1].flow = -a;

            x = edges[p[x]].from;

        }

        return a;

    }

    int maxflow() {///更新最大流

        int flow = 0;

        memset(num, 0, sizeof(num));

        memset(cur, 0, sizeof(cur));

        for(int i = 1; i <= n; i++) num[d[i]]++;

        int x = s;

        while(d[s] < n) {///最长的一条链上，最大的下标是nv-1，如果大于等于nv说明已断层

            if(x == t) {

                flow += augment();

                x = s;//回退

            }

            bool ok = 0;

            for(int i = cur[x]; i < g[x].size(); i++) {

                edge &e = edges[g[x][i]];

                if(d[x] == d[e.to] + 1 && e.cap > e.flow) {

                    p[e.to] = g[x][i];

                    cur[x] = i;x = e.to;

                    ok = 1;

                    break;

                }

            }

            if(!ok) {

                int m = n-1;

                for(int i = 0; i < g[x].size();i++) {

                    edge &e=edges[g[x][i]];

                    if(e.cap>e.flow) m=min(m,d[e.to]);

                }

                num[d[x]]--;

                if(!num[d[x]]) break;

                d[x] = m+1;

                num[d[x]]++;

                cur[x] = 0;

                if(x != s) x = edges[p[x]].from;

            }

        }

        return flow;

    }

}ISAP;

inline int id(int x, int y) {
    return (x-1) * n + y;
}

int a[507][507];

int dr[8] = {-2, -2, -1, -1, 1, 1, 2, 2};
int dc[8] = {1, -1, 2, -2, 2, -2, 1, -1};

int main()
{
    read(n); read(m);
    
    memset(a, 0, sizeof(a));
    s = 0, t = n * n + 1;
    ISAP.init(n * n * 2, s, t);
    for ( int i = 1; i <= m; ++i ) {
        int x, y;
        read(x); read(y);
        a[x][y] = 1;
    }
    for ( int i = 1; i <= n; ++i ) {
        for ( int j = 1; j <= n; ++j ) {
            if(a[i][j])
                continue;
            if((i + j) & 1) {
                ISAP.addegde(s, id(i, j), 1);
                for ( int k = 0; k <= 7; ++k ) {
                    int x = i + dr[k], y = j + dc[k];
                    if(x < 1 || x > n || y < 1 || y > n) {
                        continue;
                    }
                    ISAP.addegde(id(i, j), id(x, y), inf);
                }
            }
            else {
                ISAP.addegde(id(i, j), t, 1);
            }
        }
    }
    int maxflow = ISAP.maxflow();
    //dbg(maxflow);
    int ans = n * n - m - maxflow;
    cout << ans << endl;
    return 0;
}