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;
}
/**

*/