HDU 1565 方格取数(1)(最大点权独立集)

题目大意：给你一个n*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取的数所在的2个格子不能相邻，并且取出的数的和最大。

解题思路：最大点权独立集，关键是怎么建图了，我们可以采用染色的思想对这张图进行染色，然后分成两个点集
假设将第一个格子染成白色，然后将它相邻的格子染成相反的颜色黑色，以此类推，这样就可以将一张图分成染成黑白两种颜色的点集了
然后就是连边了，连边的话，我们只考虑白色格子的连向黑色格子的，因为两者之间是相对的，所以只需要取一条就好了
这样图就建好了
最大权值就是:总权值-最小割了(最小割就是最小点权覆盖了)具体的证明请看胡伯涛:算法合集之《最小割模型在信息学竞赛中å的应用》

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

#define M 1000010
#define N 10010
#define INF 0x3f3f3f3f
struct Edge{
    int u, v, cap, flow, next;
    Edge() {}
    Edge(int u, int v, int cap, int flow, int next): u(u), v(v), cap(cap), flow(flow), next(next) {}
}E[M];

struct Dinic{
    int head[N], d[N];
    int tot, sink, source;

    void init() {
        memset(head, -1, sizeof(head));
        tot = 0;
    }

    inline void AddEdge(int u, int v, int cap) {
        E[tot] = Edge(u, v, cap, 0, head[u]); head[u] = tot++;
        u = u ^ v; v = u ^ v; u = u ^ v;
        E[tot] = Edge(u, v, 0, 0, head[u]); head[u] = tot++;
    }

    inline bool bfs(int s) {
        int u, v;
        memset(d, 0, sizeof(d));
        queue<int> Q;
        Q.push(s);
        d[s] = 1;
        while (!Q.empty()) {
            u = Q.front(); Q.pop();
            if (u == sink) return true;
            for (int i = head[u]; ~i; i = E[i].next) {
                v = E[i].v;
                if (!d[v] && E[i].cap - E[i].flow > 0) {
                    d[v] = d[u] + 1;
                    Q.push(v);
                }
            }
        }
        return false;
    }

    int dfs(int x, int a) {
        if (x == sink || a == 0)
            return a;
        int f, flow = 0;
        for (int i = head[x]; ~i; i = E[i].next) {
            int v = E[i].v;
            if (d[v] == d[x] + 1 && E[i].cap - E[i].flow > 0) {
                f = dfs(v, min(a, E[i].cap - E[i].flow));
                E[i].flow += f;
                E[i^1].flow -= f;
                flow += f;
                a -= f;
                if (!a) break;
            }
        }
        if (flow == 0) d[x] = 0;
        return flow;
    }

    int Maxflow(int source, int sink) {
        int flow = 0;
        this->sink = sink;
        while (bfs(source)) flow += dfs(source, INF);
        return flow;
    }
};

Dinic dinic;
#define maxn 25
int n, source, sink, Sum;
int num[maxn][maxn];
bool mark[maxn][maxn];
int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

void init() {
    source = 0, sink = n * n + 1, Sum = 0;
    dinic.init();
    for (int i = 0; i < n; i++)
        for (int j = 1; j <= n; j++) {
            scanf("%d", &num[i][j]);
            Sum += num[i][j];
        }
    memset(mark, 0, sizeof(mark));
    for (int i = 0; i < n; i++)
        for (int j = 1; j <= n; j++) 
            if (!mark[i][j]) {
                dinic.AddEdge(source, i * n + j, num[i][j]);
                for (int k = 0; k < 4; k++) {
                    int x = i + dir[k][0], y = j + dir[k][1];
                    if (x < 0 || x >= n || y < 1 || y > n) continue;
                    dinic.AddEdge(i * n + j, x * n + y, INF);
                    if (!mark[x][y]) dinic.AddEdge(x * n + y, sink, num[x][y]);
                    mark[x][y] = true;
                }
            }
    printf("%d\n", Sum - dinic.Maxflow(source, sink));
}


int main() {
    while (scanf("%d", &n) != EOF) {
        init();
    }
    return 0;
}