hdu1565方格取数(1)【最大流||最大点权独立集】

Problem Description

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

 

 

Input

包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20)

 

 

Output

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

 

 

Sample Input

3 75 15 21 75 15 28 34 70 5

 

 

Sample Output

188

 

 

预备知识：

对于一个无向图G，点有各自的权值

 

点覆盖集：一个点集，使G中所有的边至少有一个点在该集合内

最小点权覆盖集：权值和最小的点覆盖集

 

点独立集：一个点集，该集合中任意两个点都没有边相连

最大点权独立集：全职和最大的点独立集

 

定理：

1、最小点权覆盖集 = 最小割 = 最大流

2、最大点权独立集 = 总权值 - 最小点权覆盖集

 

分析：

该题是二分图中的最大点权独立集的题目

可以用网络流来做

将每个格子抽象成一个点，相邻格子分别涂成黑色和白色

将源点和白色点连一条边，权值为白色点的权值

将白点和它所能到达的白点连一条边，权值为INF

将黑点和汇点连一条边，权值为黑点的权值

这样求出来的网络流便是最小点权覆盖集

然后用总权值减去即可

细节处理：将图上的各点先转化为数字，奇数行奇数列上的点跟偶数行偶数列上的点是同色的

 

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

const int maxn = 205 << 1;
const int INF = 1000000000;

int map[25][25], a[25][25];
int xx[4] = { 0, 0, 1, -1 };
int yy[4] = { 1, -1, 0, 0 };

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

struct Dinic
{
    int n, m, s, t;
    vector<Edge> edges;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void ClearAll(int n) {
        for(int i = 0; i <= n; i++) {
            G[i].clear();
        }
        edges.clear();
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back((Edge){from, to, cap, 0} );
        edges.push_back((Edge){to, from, 0, 0} );
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
        //printf("%din end\n",m);
    }

    bool BFS()
    {
        memset(vis, 0, sizeof(vis) );
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        while(!Q.empty() ){
            int x = Q.front(); Q.pop();
            for(int i = 0; i < G[x].size(); i++) {
                Edge& e = edges[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x, int a) {
        if(x == t || a == 0) return a;
        int flow = 0, f;
        for(int& i = cur[x]; i < G[x].size(); i++) {
            Edge& e = edges[G[x][i]];
            if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
        return flow;
    }

    int MaxFlow(int s, int t) {
        this -> s = s; this -> t = t;
        int flow = 0;
        while(BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
};

Dinic g;

int main() {
    int n;
    //freopen("b.txt","r",stdin);
    while(EOF != scanf("%d",&n) ) {
        int tot = 1;
        int sum = 0;
        int s = 0; int t = n * n + 1;
        for(int i = 1;i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d",&a[i][j]);
                sum += a[i][j];
                map[i][j] = tot++;
            }
        }
        g.ClearAll(maxn);
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {

                if(i % 2 == 1 && j % 2 == 1) {
                    g.AddEdge(s, map[i][j], a[i][j]);
                    for(int k = 0; k < 4; k++) {
                        int tmpx = i + xx[k]; int tmpy = j + yy[k];
                        if(tmpx >= 1 && tmpx <= n && tmpy >= 1 && tmpy <= n) {
                            g.AddEdge(map[i][j], map[tmpx][tmpy], INF);
                            //printf("%d %d %d\n",tmpx, tmpy, map[tmpx][tmpy]);
                        }
                    }
                }

                if(i % 2 == 0 && j % 2 == 0) {
                    g.AddEdge(s, map[i][j], a[i][j]);
                    for(int k = 0; k < 4; k++) {
                        int tmpx = i + xx[k]; int tmpy = j + yy[k];
                        if(tmpx >= 1 && tmpx <= n && tmpy >= 1 && tmpy <= n) {
                            g.AddEdge(map[i][j], map[tmpx][tmpy], INF);
                        }
                    }
                }

                if(i % 2 == 1 && j % 2 == 0) {
                    g.AddEdge(map[i][j], t, a[i][j]);
                }
                if(i % 2 == 0 && j % 2 == 1) {
                    g.AddEdge(map[i][j], t, a[i][j]);
                }
            }
        }
        //printf("%d %d\n",sum, g.MaxFlow(s, t));
        printf("%d\n",sum - g.MaxFlow(s, t) );
    }
    return 0;
}