HDU 1569 方格取数(2)（最大流最小割の最大权独立集）

Description

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

 

Input

包括多个测试实例，每个测试实例包括2整数m,n和m*n个非负数(m<=50,n<=50)

 

Output

对于每个测试实例，输出可能取得的最大的和

 

题目大意：这么短还中文就没大意了，唯一要注意的就是输入的第一个是行第二个是列……

思路：这题为最大权独立集（所选的点之间都没有边）。建立一个最大流的二分图，i+j为偶数的放左边，源点S连一条边到它，容量为格子里的数，其余放右边，连一条边到汇点T，容量还是格子里的数，相邻的都从左到右连一条边，容量为无穷大。所有数字之和减去最大流即为答案。

小证明：这样构图求出的最大流为最小权覆盖集（所有边至少被一个点覆盖），详见POJ 3308 Paratroopers（最大流最小割の最小点权覆盖）

而最小权覆盖集与最大权独立集是对偶图，把最小权覆盖集里的点都取反，就可以得到一个最大权独立集，所以总权 = 最小权覆盖集 + 最大权独立集。详见二分图中的对偶问题

 

代码（15MS）：

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

const int MAXN = 3000;
const int MAXE = 30010;
const int INF = 0x3fff3fff;

struct SAP {
    int head[MAXN], dis[MAXN], pre[MAXN], cur[MAXN], gap[MAXN];
    int to[MAXE], next[MAXE], flow[MAXE];
    int n, st, ed, ecnt;

    void init() {
        memset(head, 0, sizeof(head));
        ecnt = 2;
    }

    void add_edge(int u, int v, int c) {
        to[ecnt] = v; flow[ecnt] = c; next[ecnt] = head[u]; head[u] = ecnt++;
        to[ecnt] = u; flow[ecnt] = 0; next[ecnt] = head[v]; head[v] = ecnt++;
        //printf("%d->%d flow = %d\n", u, v, c);
    }

    void bfs() {
        memset(dis, 0x3f, sizeof(dis));
        queue<int> que; que.push(ed);
        dis[ed] = 0;
        while(!que.empty()) {
            int u = que.front(); que.pop();
            ++gap[dis[u]];
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p ^ 1] && dis[v] > n) {
                    dis[v] = dis[u] + 1;
                    que.push(v);
                }
            }
        }
    }

    int Max_flow(int ss, int tt, int nn) {
        st = ss; ed = tt; n = nn;
        int ans = 0, minFlow = INF, u;
        for(int i = 0; i <= n; ++i) {
            cur[i] = head[i];
            gap[i] = 0;
        }
        u = pre[st] = st;
        bfs();
        while(dis[st] < n) {
            bool flag = false;
            for(int &p = cur[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && dis[u] == dis[v] + 1) {
                    flag = true;
                    minFlow = min(minFlow, flow[p]);
                    pre[v] = u;
                    u = v;
                    if(u == ed) {
                        ans += minFlow;
                        while(u != st) {
                            u = pre[u];
                            flow[cur[u]] -= minFlow;
                            flow[cur[u] ^ 1] += minFlow;
                        }
                        minFlow = INF;
                    }
                    break;
                }
            }
            if(flag) continue;
            int minDis = n - 1;
            for(int p = head[u]; p; p = next[p]) {
                int &v = to[p];
                if(flow[p] && minDis > dis[v]) {
                    minDis = dis[v];
                    cur[u] = p;
                }
            }
            if(--gap[dis[u]] == 0) break;
            gap[dis[u] = minDis + 1]++;
            u = pre[u];
        }
        return ans;
    }
} G;

int n, m;
int mat[55][55];

int main() {
    while(scanf("%d%d", &n, &m) != EOF) {
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= m; ++j) scanf("%d", &mat[i][j]);
        G.init();
        int ss = n * m + 1, tt = n * m + 2;
        int cnt = 0, sum = 0;
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= m; ++j) {
                ++cnt; sum += mat[i][j];
                if((i + j) & 1) {
                    G.add_edge(ss, cnt, mat[i][j]);
                    if(j != 1) G.add_edge(cnt, cnt - 1, INF);
                    if(i != 1) G.add_edge(cnt, cnt - m, INF);
                    if(j != m) G.add_edge(cnt, cnt + 1, INF);
                    if(i != n) G.add_edge(cnt, cnt + m, INF);
                }
                else G.add_edge(cnt, tt, mat[i][j]);
            }
        }
        printf("%d\n", sum - G.Max_flow(ss, tt, tt));
    }
}