HDU 方格取数(网络流24题，八)

                                                                     方格取数(2)

题目链接：Click Here~

题目分析：

   跟方格取数(一)一样的，就是数据变大了一点。就是在做网络流24题的时候看解析说可以用最小割，但是建图的时候不理解为什么可以那样分成黑白两色进行建图。虽然，知道那是最小割的性质，但放在改题上还是不理解。

【建模方法】

首先把棋盘黑白染色，使相邻格子颜色不同，所有黑色格子看做二分图X集合中顶点，白色格子看做Y集合顶点，建立附加源S汇T。

1、从S向X集合中每个顶点连接一条容量为格子中数值的有向边。
2、从Y集合中每个顶点向T连接一条容量为格子中数值的有向边。
3、相邻黑白格子Xi,Yj之间从Xi向Yj连接一条容量为无穷大的有向边。

求出网络最大流，要求的结果就是所有格子中数值之和减去最大流量。

【建模分析】

这是一个二分图最大点权独立集问题，就是找出图中一些点，使得这些点之间没有边相连，这些点的权值之和最大。独立集与覆盖集是互补的，求最大点权独立集可以转化为求最小点权覆盖集（最小点权支配集）。最小点权覆盖集问题可以转化为最小割问题解决。结论:最大点权独立集 = 所有点权 - 最小点权覆盖集 = 所有点权 - 最小割集 = 所有点权 - 网络最大流。

对于一个网络，除去冗余点（不存在一条ST路径经过的点），每个顶点都在一个从S到T的路径上。割的性质就是不存在从S到T的路径，简单割可以认为割边关联的非ST节点为割点，而在二分图网络流模型中每个点必关联到一个割点（否则一定还有增广路，当前割不成立），所以一个割集对应了一个覆盖集（支配集）。最小点权覆盖集就是最小简单割，求最小简单割的建模方法就是把XY集合之间的变容量设为无穷大，此时的最小割就是最小简单割了。

有关二分图最大点权独立集问题，更多讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

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

const int INF = ~0U>>2;
const int MAXN = 2500+5;
const int dir[5][3] = {{0,1},{0,-1},{1,0},{-1,0}};
struct Edge{
   int from,to,cap,flow;
   Edge(int f,int t,int c,int _f)
       :from(f),to(t),cap(c),flow(_f){};
};
class MinCut{
public:
    void Init();
    void AddEdge(int from,int to,int cap);
    bool BFS();
    int DFS(int u,int a);
    int Maxflow();
    int Solve(int n,int m);
private:
    vector<Edge> edges;
    vector<int> G[MAXN];
    int S,T,N,M;
    int cur[MAXN],d[MAXN];
    bool vst[MAXN];
};
void MinCut::Init()
{
    for(int i = 0;i < MAXN;++i)
      G[i].clear();
    edges.clear();
}
inline void MinCut::AddEdge(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int sz = edges.size();
    G[from].push_back(sz-2);
    G[to].push_back(sz-1);
}
bool MinCut::BFS()
{
    memset(vst,false,sizeof(vst));
    vst[S] = true; d[S] = 0;

    queue<int> Q;
    Q.push(S);
    while(!Q.empty()){
        int u = Q.front();
        Q.pop();
        for(int i = 0;i < (int)G[u].size();++i){
            Edge& e = edges[G[u][i]];
            if(!vst[e.to]&&e.cap > e.flow){ //在残流网络中找
                vst[e.to] = true;
                d[e.to] = d[u]+1;
                Q.push(e.to);
            }
        }
    }
    return vst[T];
}
int MinCut::DFS(int u,int a)
{
    if(u==T||a==0)
        return a;
    int f,flow = 0;
    for(int& i = cur[u];i < (int)G[u].size();i++){
        Edge& e = edges[G[u][i]];
        if(d[e.to]==d[u]+1&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int MinCut::Maxflow()
{
    int flow = 0;
    while(BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(S,INF);
    }
    return flow;
}
int MinCut::Solve(int n,int m)
{
    int c,ans,Total = 0,top = 0;
    int Map[55][55];
    N = n; M = m;
    S = 0; T = N*M+1;
    Init();
    //将图分成X部和Y部
    for(int i = 1;i <= N;++i){
        for(int j = 1;j <= M;++j){
            scanf("%d",&c);
            Total += c;
            Map[i][j] = ++top;
            if((i+j)%2==0)
               AddEdge(S,top,c);
            else
               AddEdge(top,T,c);
        }
    }
    //将无关的点设INF
    for(int i = 1;i <= N;++i){
        for(int j = 1;j <= M;++j){
            if((i+j)%2==0){
                for(int k = 0;k < 4;++k){
                    int x = i + dir[k][0];
                    int y = j + dir[k][1];
                    if(x>=1&&y>=1&&x<=N&&y<=M)
                        AddEdge(Map[i][j],Map[x][y],INF);
                }
            }
        }
    }
    ans = Maxflow();          // printf("ans = %d\n",ans);
    return Total - ans;
}
MinCut mc;
int main()
{
    int n,m,ans;
    while(~scanf("%d%d",&n,&m))
    {
         ans = mc.Solve(n,m);
         printf("%d\n",ans);
    }
    return 0;
}