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 = ;
 const int MAXE = ;
 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, , sizeof(head));
         ecnt = ;
     }

     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] = ; 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] = ;
         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 ^ ] && dis[v] > n) {
                     dis[v] = dis[u] + ;
                     que.push(v);
                 }
             }
         }
     }

     int Max_flow(int ss, int tt, int nn) {
         st = ss; ed = tt; n = nn;
         int ans = , minFlow = INF, u;
         for(int i = ; i <= n; ++i) {
             cur[i] = head[i];
             gap[i] = ;
         }
         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] + ) {
                     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] ^ ] += minFlow;
                         }
                         minFlow = INF;
                     }
                     break;
                 }
             }
             if(flag) continue;
             int minDis = n - ;
             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]] == ) break;
             gap[dis[u] = minDis + ]++;
             u = pre[u];
         }
         return ans;
     }
 } G;

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

 int main() {
     while(scanf("%d%d", &n, &m) != EOF) {
         for(int i = ; i <= n; ++i)
             for(int j = ; j <= m; ++j) scanf("%d", &mat[i][j]);
         G.init();
         int ss = n * m + , tt = n * m + ;
         int cnt = , sum = ;
         for(int i = ; i <= n; ++i) {
             for(int j = ; j <= m; ++j) {
                 ++cnt; sum += mat[i][j];
                 if((i + j) & ) {
                     G.add_edge(ss, cnt, mat[i][j]);
                     if(j != ) G.add_edge(cnt, cnt - , INF);
                     if(i != ) G.add_edge(cnt, cnt - m, INF);
                     if(j != m) G.add_edge(cnt, cnt + , 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));
     }
 }