HDU3657Game（最大流）

这几天敲了几道最大流的问题，发现网络流真是模板算法啊。。。。

敲来敲去敲了几遍，基本每遍都敲得让人灰心，但同时也感受到了网络流的强大所在，这是我做网络流的第一题，，本以为看了一遍小白书的代码差不多理解就可以A掉一题的，没想到打击不是一点点的少啊。。。。。

首先小白书将的邻接矩阵存边，这里必须用邻接表，而本以为随便改改就好的，没想到那个记录路径却让人头疼得要命，无赖之下看了题解，看到了一个名为SAP的强大算法，虽然比小白的代码量增加了不少，理解起来也不是很容易，但是复杂度真心减少了不知一点点啊！！！！

虽然履步维艰，最后慢慢看着大牛模板一点一点敲了出来，可是其实还不是特别的了解的说，只是大致明白了思路而已，没办法看不懂就背下来吧，相信敲得多了自然就会慢慢理解记住的。。。

下面的SAP代码风格是我在网上找了一些后自己最觉得满意的一种（看到很多人使用loop；goto语句，真心不想用那样的句子啊，真心强迫症患者啊。。。。）

 (能有自己的网络流模板感觉真好~~~)

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf ((LL)1<<40)
#define lson k<<1, L, mid
#define rson k<<1|1, mid+1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FOPENIN(IN) freopen(IN, "r", stdin)
#define FOPENOUT(OUT) freopen(OUT, "w", stdout)
template<class T> T ABS ( T a) { return a >= 0 ? a : -a;   }
template<class T> T CMP_MIN ( T a, T b ) { return a < b;   }
template<class T> T CMP_MAX ( T a, T b ) { return a > b;   }
template<class T> T MAX ( T a, T b ) { return a > b ? a : b; }
template<class T> T MIN ( T a, T b ) { return a < b ? a : b; }
template<class T> T GCD ( T a, T b ) { return b ? GCD ( b, a % b ) : a; }
template<class T> T LCM ( T a, T b ) { return a / GCD ( a, b ) * b;     }
template<class T> void SWAP( T& a, T& b ) { T t = a; a = b;  b = t;     }

typedef __int64 LL;
//typedef long long LL;
const int MAXN = 101000;
const int MAXM = 500100;
const double eps = 1e-14;
const double PI = 4.0 * atan(1.0);
const LL MOD = 1000000007;

int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};

int n, m, k, ma[55][55], mus[55][55], sum;

struct Edge { int to, cap, next; }edge[MAXM<<1];
int head[MAXN], tot;

int src, des;
int dep[MAXN], gap[MAXN], pre[MAXN], aug[MAXN], cur[MAXN];

void init()
{
    int x, y;
    mem0(mus); mem0(edge);sum = 0;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++ )
        {
            scanf("%d", &ma[i][j]);
            sum += ma[i][j];
        }
    }
    for(int i = 0; i < k; i ++)
    {
        scanf("%d %d", &x, &y);
        mus[x][y] = 1;
    }
}

void addEdge(int u, int v, int val)
{
    edge[tot].to = v; edge[tot].cap = val;   edge[tot].next= head[u];
    head[u] = tot ++;
    edge[tot].to = u; edge[tot].cap = 0;     edge[tot].next = head[v];
    head[v] = tot ++;
}

void init_Edge()
{
    mem1(head); tot = 0;
    src = 0; des = m * n + 1;
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 1; j <= m; j ++)
        {
            int now = (i-1)*m + j;
            if((i+j)&1){
                if(mus[i][j]) addEdge(now, des, INF);
                else addEdge(now, des, ma[i][j]);
            }
            else {
                if(mus[i][j]) addEdge(src, now, INF);
                else addEdge(src, now, ma[i][j]);
                for(int k = 0; k < 4; k ++ ) {
                    int nx = i + dx[k], ny = j + dy[k];
                    if(nx>0 && nx<=n && ny>0 && ny<=m)
                        addEdge(now, (nx-1)*m+ny, 2*(ma[i][j]&ma[nx][ny]));
                }
            }
        }
    }
}

int SAP(int n)
{
    mem0(aug);   mem0(pre);
    mem(dep, 0); mem(gap, 0);
    int max_flow = 0, u = src;
    aug[src] = INF;
    pre[src] = -1;
    gap[0] = n;
    for(int i = 0; i <= n; i ++)
        cur[i] = head[i];
    while(dep[src] < n)
    {
        //printf("%d\n", u);
        if(u == des)
        {
          //  printf("%d\n", max_flow);
            max_flow += aug[des];
            for(int v = pre[des]; v != -1; v = pre[v])
            {
                int e = cur[v];
                edge[e].cap   -= aug[des];
                edge[e^1].cap += aug[des];
                aug[v] -= aug[des];
                if(edge[e].cap == 0) u = v;
                //u = src;
            }
        }
        int flag = 0;
        for(int e = cur[u]; e != -1; e = edge[e].next)
        {
            int v = edge[e].to;
            if(edge[e].cap > 0 && dep[u] == dep[v] + 1)
            {
                flag = 1;
                pre[v] = u; cur[u] = e;
                aug[v] = MIN(aug[u], edge[e].cap);
                u = v;
                break;
            }
        }
        if(!flag)
        {
            if(--gap[dep[u]] == 0)
                break;
            int min_dep = n;
            cur[u] = head[u];
            for(int e = head[u]; e != -1; e = edge[e].next)
            {
                int v = edge[e].to;
                if(edge[e].cap > 0 && dep[v] < min_dep)
                {
                    min_dep = dep[v];
                    cur[u] = e;
                }
            }
            dep[u] = min_dep + 1;
            gap[dep[u]] ++;
            if(u != src) u = pre[u];
        }
    }
    return max_flow;
}

int main()
{
    while(~scanf("%d %d %d", &n, &m, &k))
    {
        init();
        init_Edge();
        printf("%d\n", sum - SAP(des+1));
    }
    return 0;
}