hdu_1565(网络流)

解法一、网络流

相邻的点染不同颜色：

　　(行数+列数)为奇数的染成白色，(行数+列数)为偶数的染成白色

source = 0, sink = n*n+1.

source到每个白点连接，流量为白点的值

黑点到sink连接，流量为黑点的值

每个白点与其周围的黑点连接，流量为INT_MAX

所有点的值的总和 - 最大流量 = 所求答案

以下是抄来的原理：

　　点覆盖集：无向图G的一个点集，使得该图中所有边都至少有一个端点在该集合内。

　　最小点权覆盖集：在带点权无向图G中，点权之和最小的覆盖集。

　　点独立集：无向图G的一个点集，使得任两个在该集合中的点在原图中都不相邻。
　　最大点权独立集：在带权无向图G中，点权之和最大的独立集。

　　定理：
　　　　1. 二分图的最小点权覆盖集=最小割=最大流
　　　　2. 二分图的最大点权独立集=总权-最小点权覆盖集

#include <cstdio>
#include <climits>
#include <cstring>
#include <queue>

#define MAXN 20

const int source = 0;
int n, G[MAXN*MAXN+10][MAXN*MAXN+10], layer[MAXN*MAXN+10], total, sink;
bool vis[MAXN*MAXN+10];

bool bfs()
{
    memset(layer, -1, sizeof(layer));
    std::queue<int> q;
    q.push(source);
    layer[source] = 0;
    while(q.empty()==false){
        int u = q.front();
        q.pop();
        for(int v = 1; v <= sink; ++v){
            if(layer[v] == -1 && G[u][v] > 0){
                layer[v] = layer[u] + 1;
                if(v == sink)
                    return true;
                q.push(v);
            }
        }
    }
    return false;
}

int dinic()
{
    int max_flow = 0;
    while(bfs() == true){
        memset(vis,false,sizeof(vis));
        vis[source] = true;
        int st[MAXN*MAXN+10];
        int top = 0;
        st[++top]= source;
        while(top > 0) {
            int u = st[top];
            if(u == sink) {
                int current = INT_MAX;
                int key_path;
                for(int i = 1; i < top; ++i) {
                    int s = st[i];
                    int e = st[i+1];
                    if(current > G[s][e]) {
                        current = G[s][e];
                        key_path = i;
                    }
                }
                for(int i = 1; i < top; ++i) {
                    int s = st[i];
                    int e = st[i+1];
                    G[s][e] -= current;
                    G[e][s] += current;
                }

                max_flow += current;
                while(top > key_path) {
                    vis[st[top--]] = false;
                }
            }
            else {
                int v;
                for(v= 1; v <= sink; ++v) {
                    if(layer[v] == layer[u]+1 && vis[v] == false && G[u][v] > 0) {
                        vis[v] = true;
                        st[++top] = v;
                        break;
                    }
                }
                if(v == sink+1) {
                    top--;
                }
            }
        }
    }
    return max_flow;
}

void init()
{
    memset(G, 0, sizeof(G));
    total = 0;
    sink = n*n+1;
    for(int i = 1, input_buffer; i <= n*n; ++i){
        scanf("%d", &input_buffer);
        total += input_buffer;
        int row = (i-0.1) / n + 1;
        int column = (i % n == 0) ? (n) : (i % n);
        // if (row + column) is odd number, link source to this cell.
        if( (row + column)&1 ){
            G[source][i] = input_buffer;

            if(i%n != 1)
                G[i][i-1] = INT_MAX;
            if(i%n != 0)
                G[i][i+1] = INT_MAX;
            if(i > n)
                G[i][i-n] = INT_MAX;
            if(i <= n*n-n)
                G[i][i+n] = INT_MAX;
        }
        // if (row + column) is even number, link this cell to sink.
        else
            G[i][sink] = input_buffer;
    }
}

int main(int argc, char const *argv[])
{
    // freopen("in", "r", stdin);
    while(~scanf("%d", &n)){
        init();
        printf("%d
", total - dinic());
    }
    return 0;
}