HDU 1569 方格取数(2)

/**
    对于此题, 唯一想到的是不能搞的:暴搜,还有转移方程不明的dp~~~
    这种题必须对相关算法有一定的了解, 依靠前人已经总结的智慧,
    俗话说站在巨人的肩膀上, 不然想破头皮都没用~~~
     还是先学学算法吧, 领会算法的就一眼望穿了~~~, 继续水~~~
  ————————————————————————————————————
    学习了下,大神们的博客, 网络流, 裸求最大点权独立集
算法:   对于----  “有权二分图！！”

                 最大点权独立集 + 最小点权覆盖集 = 总点权和
        ==>  最大点权独立集 = 点权总和 - 最小点权覆盖;

        如字面上理解,　最小点权覆盖的点去掉之后,剩下的就是最大点权独立集
        类似于普通二分图, 最小点覆盖 + 最大独立集 = 点数
------------------------------------------------------------------------------------------------------------
建图:         经典黑白点相邻的图,
                    黑点连一个超级源点做割的点集S,
                    白点连接一个超级汇点做点集T,
                    相邻的黑白点连接权值无穷大的边,

        此时： 最小割 = 最小点权覆盖
        又：      最小割 = 最大流

       那么求出最大流就行了, 俄用E_K;
---------------------------------------------------------------------------------------------------------------
        补盲:
                        最小割 = 最大流
                                (1)网络流f等于任何割的|正容量 - 逆容量| , 则f为最大流
                                (2)当割的逆向割边容量和为0, 则割为最小割(容量最小的割)
                                (3)割容量:割的正向割边的和
-----------------------------------------------------------------------------------------------------------------

    那为什么要这样建图, 最小割 = 最小点权覆盖呢：
                                                      1.把相近的点以无穷边权连接, 在选取最小割的时候不会选取
                                                          从而避免了选取相邻的点
                                                       2.割边必然包含在S或者T所在的边, 刚好能覆盖所有点,选取不会遗漏
                                                       3.割最小的时候, 就是去掉权值最小点集,   但是这些点也正好能覆盖
                                                           所有的边,所以就是最小点权覆盖
*/

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <algorithm>
//#include "myAlgorithm.h"

#define MAX 52
#define OFFENCE (1e9 + 5)
#define INF (1e8 + 5)
#define eps 1e-9
#define Rep(s, e) for( int i = s; i <= e; i++)
#define Cep(e, s) for( int j = e; j >= s; j --)
#define PI acos(-1.0)
//#pragma comment(linker, "/STACK:36777216") ///传说中的外挂
using namespace std;

int m, n;
int mp[MAX][MAX];
//bool v[MAX][MAX];

int path[MAX * MAX], minFlow, flow[MAX * MAX][MAX * MAX];
int src = 0, end;

struct Ed {
    int pos, val,next;
} ed[MAX * MAX * 5];
int head[MAX * MAX], e, ans, a[MAX * MAX];
void insert(int a, int b, int val) {
    ed[e].next = head[a];
    ed[e].pos = b;
    ed[e].val = val;
    head[a]  = e++;
}

void init() {
    e  = 0;
    ans = 0;
    memset(head, -1, sizeof(head));
    //memset(v, 0, sizeof(v));
    memset(flow, 0, sizeof(flow));
}
bool isBlack(int i, int j) { ///第一个点成黑色, 1 黑 0白
    return (i  +  j) % 2;
}
bool isOk(int i, int j) {
    return (i <= m && j <= n && i >0 && j > 0 );
}
int dir[][2] = {{-1, 0},{1, 0},{0, 1},{0, -1}};

void make_graph2(){

    for(int i  = 1; i <= m; i++){
        for(int j = 1; j <= n;j++){
            int u = (i - 1) * n + j;
            if(isBlack(i, j)){
                insert(0, u, mp[i][j]);
            }else {
                insert(u, m * n + 1 ,mp[i][j]);
            }
        }
    }

    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++){
            if(isBlack(i, j)){
                int u = (i - 1) * n + j;
                for(int k = 0; k < 4; k++){
                    int I = i + dir[k][0], J = j + dir[k][1];
                    if(isOk(I, J)){
                        int v = (I - 1) * n + J;
                        insert(u, v, INF);
                        insert(v, u, 0);
                    }
                }
            }
        }
    }
}
int bfs() {
    end = m * n + 1;
    queue<int>q;
   memset(a, 0, sizeof(a));
    q.push(src);
    a[src] = INF;
    minFlow = INF;
    while(!q.empty()) {
        int node = q.front(); q.pop();
        if(node == end)break;
        int next = head[node];
        while(next != -1) {
            int pos = ed[next].pos;
            if(a[pos] == 0 &&ed[next].val > flow[node][pos]) { ///没访问到且 可流过非0流量
                a[pos] = min(a[node], ed[next].val - flow[node][pos]);
                path[pos] = node;
                q.push(pos);
            }
            next = ed[next].next;
        }
        //cout<<node<<"queuing"<<endl;
    }
    if(a[end] == 0)return -1;///无法增广了
    return a[end];
}
int EK() {
    int maxFlow = 0, pre, now, step;
    while((step = bfs())!= -1) {
        maxFlow += step;
        now = end;
        //cout<<"step: "<<step<<endl;
        //getchar();
        while(now != src) {
            pre = path[now];
            flow[pre][now] += step;
            flow[now][pre] -= step;
            now = pre;
//            cout<<"----------Looping"<<endl;
        }
    }
    //cout<<maxFlow<<endl;
    return maxFlow;
}
int main() {

    while(cin>>n) {
        m = n;
        init();
        for(int i = 1; i <= m; i++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d", &mp[i][j]);
                ans += mp[i][j];
            }
        }///end input;
        make_graph2();
        cout<<ans - EK()<<endl;
    }
    return 0;
}
/**

*/