[网络流 24 题] 方格取数问题 骑士共存问题

LOJ6007 https://loj.ac/problem/6007
LOJ6226 https://loj.ac/problem/6226
luogu2774 https://www.luogu.org/problemnew/show/P2774
luogu3355 https://www.luogu.org/problemnew/show/P3355

这两道题都差不多，就放在一起写了。两道题的话原题就不贴过来了，只放一个题目链接。

方格取数问题的题意很明显，互相连着的两个数不能一起取走。这样的话，我们将图染成黑白两种颜色，并建立一个二分图，将一种颜色的点放在左侧，另一种颜色的点放在右侧。并各与源点、汇点连一条容量为该点的数值的边。
将一个点与其相邻的点用一条容量为INF的边连接起来。
这样我们就建立了一个二分图，之后跑一边最大流，之后怎么办呢，我们先看一下骑士共存问题。

骑士共存问题上来一看很难，骑士只要画一下图就可以发现，对对角线上的骑士是永远都不会互相攻击到的，所以我们只要像方格取数问题一样，将所有点染色，然后连一下图就可以了。这时所有的边的容量都是1。
连图具体的方案是枚举每个点，将该点和该店可以攻击到的点连一条容量为1的边。
之后求出该图的最大流，我们知道对于一个二分图，最大流就是该图的最大匹配，也就是说我们求出了该图的最大匹配。而对于每个匹配的两个点，它们都是可以互相攻击到的，所以我们只能取其中的一个，也就是说，用骑士的总数减去最大匹配的数量就可以得到答案了，其实这也就是二分图的最大独立集。
还要注意的就是，要把有障碍的点排除一下。

我们再回头来看方格取数问题，这一题每个格子上都有自己的权值，而我们用了容量来代表这个权值。容易发现，对于一个“匹配”， 通过他的流量是两个点中容量的最小的值，这样的话，我们就可以用所有数字的和减去最大流，就可以得出解了。
这两道题还要注意的是空间是否开够。

代码：
方格取数问题

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
const int INF = 1<<29;

int n, m, s, t, sum=0;
int tot=1, front[MAXN];
int cur[MAXN], layer[MAXN];

struct tEdge
{
    int v, next, c, f;
    inline void addEdge(int tmpu, int tmpv, int tmpc)
    {
        c = tmpc; v = tmpv; f = 0;
        next = front[tmpu];
        front[tmpu] = tot;

        //printf("u:%d, v:%d, c:%d\n", tmpu, v, c);
    }
} e[MAXN*MAXN*2];

bool bfs()
{
    queue <int> q;
    memset(layer, 0, sizeof(layer));
    layer[s] = 1; q.push(s);

    while(!q.empty())
    {
        int u = q.front(); q.pop(); 

        for(int i=front[u]; i>0; i=e[i].next)
        {
            int v = e[i].v, maxflow = e[i].c - e[i].f;

            if(maxflow <= 0) continue;
            if(layer[v] != 0) continue;

            layer[v] = layer[u] + 1;
            q.push(v);
            if(v == t) return true;
        }
    }

    //printf("layer[t]:%d\n", layer[t]);
    return false;
}

int dfs(int u, int curflow)
{
    if(u == t || curflow == 0) return curflow;
    int flow = 0;

    for(int &i=cur[u]; i>0; i=e[i].next)
    {
        int v = e[i].v, maxflow = e[i].c - e[i].f;

        if(maxflow <= 0) continue;
        if(layer[v] != layer[u] + 1) continue;

        int nowflow = dfs(v, min(curflow, maxflow));
        flow += nowflow;
        curflow -= nowflow;
        e[i].f += nowflow;
        e[i^1].f -= nowflow;

        if(curflow == 0) break;
    }

    return flow;
}

int dinic()      
{
    int flow = 0;
    while(bfs() == true)
    {
        //printf("ok");
        for(int i=1; i<=m*n+2; i++) cur[i] = front[i];
        flow += dfs(s, INF);

        //printf("flow:%d\n", flow);
    }
    return flow;
}

int main()
{
    scanf("%d%d", &m, &n);
    s = m*n+1, t = m*n+2;

    for(int i=1; i<=m; i++)
    {
        for(int j=1; j<=n; j++)
        {
            int tmp, now=(i-1)*n+j;
            scanf("%d", &tmp); sum += tmp;

            if((i+j)%2 == 0)
            {
                e[++tot].addEdge(s, now, tmp);
                e[++tot].addEdge(now, s, 0);
                if(i-1 >= 1)
                {
                    e[++tot].addEdge(now, (i-2)*n+j, INF);
                    e[++tot].addEdge((i-2)*n+j, now, 0);
                }
                if(i+1 <= m)
                {
                    e[++tot].addEdge(now, i*n+j, INF);
                    e[++tot].addEdge(i*n+j, now, 0);
                }
                if(j-1 >= 1)
                {
                    e[++tot].addEdge(now, now-1, INF);
                    e[++tot].addEdge(now-1, now, 0); 
                }
                if(j+1 <= n)
                {
                    e[++tot].addEdge(now, now+1, INF);
                    e[++tot].addEdge(now+1, now, 0);
                }
            }
            else
            {
                e[++tot].addEdge(now, t, tmp);
                e[++tot].addEdge(t, now, 0);
            }
        }
    }

    int flow = dinic();
    printf("%d\n", sum - flow);

    return 0;
}

骑士共存问题

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
const int INF = 1<<30;

int n, m, s, t, sum=0;
int tot=1, front[MAXN];
int cur[MAXN], layer[MAXN];
bool block[500][500];

int dx[8] = {1, 2, 1, 2, -1, -2, -1, -2};
int dy[8] = {2, 1, -2, -1, 2, 1, -2, -1}; 

struct tEdge
{
    int v, next, c, f;
    inline void addEdge(int tmpu, int tmpv, int tmpc)
    {
        c = tmpc; f = 0;
        next = front[tmpu];
        front[tmpu] = tot;
        v = tmpv;
    }
} e[5000000];

void add(int tmpu, int tmpv, int tmpc)
{
    e[++tot].addEdge(tmpu, tmpv, tmpc);
    e[++tot].addEdge(tmpv, tmpu, 0);

    //printf("u:%d, v:%d, c:%d\n", tmpu, tmpv, tmpc);
}

bool bfs()
{
    queue <int> q;
    memset(layer, 0, sizeof(layer));
    layer[s] = 1; q.push(s);

    while(!q.empty())
    {
        int u = q.front(); q.pop(); 

        for(int i=front[u]; i>0; i=e[i].next)
        {
            int v = e[i].v, maxflow = e[i].c - e[i].f;

            if(maxflow <= 0) continue;
            if(layer[v] != 0) continue;

            layer[v] = layer[u] + 1;
            q.push(v);
            if(v == t) return true;
        }
    }

    return false;
}

int dfs(int u, int curflow)
{
    if(u == t || curflow == 0) return curflow;
    int flow = 0;

    for(int &i=cur[u]; i>0; i=e[i].next)
    {
        int v = e[i].v, maxflow = e[i].c - e[i].f;

        if(maxflow <= 0) continue;
        if(layer[v] != layer[u] + 1) continue;

        int nowflow = dfs(v, min(curflow, maxflow));
        curflow -= nowflow;
        e[i].f += nowflow;
        e[i^1].f -= nowflow;
        flow += nowflow;

        if(curflow == 0) break;
    }

    return flow;           
}

int dinic()
{
    int flow = 0;
    while(bfs() == true)
    {
        for(int i=1; i<=n*n+2; i++) cur[i] = front[i];
        flow += dfs(s, INF);
        //printf("flow:%d\n", flow);
    }
    return flow;
}

int main()
{
    scanf("%d%d", &n, &m);
    s = n*n +1; t = n*n +2;

    for(int i=1; i<=m; i++)
    {
        int tmp1, tmp2;
        scanf("%d%d", &tmp1, &tmp2);
        block[tmp1][tmp2] = true;
    }

    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            if(block[i][j] == true) continue;
            int now = (i-1)*n+j; sum ++;

            if((i+j) %2 == 0)
            {
                add(s, now, 1);
                for(int k=0; k<8; k++)
                {
                    int x = i+dx[k], y = j+dy[k];
                    if(x<1 || y<1 || x>n || y>n) continue;
                    if(block[x][y] == true) continue;

                    int tmp = (x-1)*n+y;
                    add(now, tmp, 1);
                }
            }
            else add(now, t, 1);
        }
    }

    int flow = dinic();
    printf("%d\n", sum - flow);

    return 0;
}