方格取数问题（最大流）

想看更多图论题目？请点击：http://blog.csdn.net/martinue/article/category/5601005

Description

    在一个有m*n 个方格的棋盘中，每个方格中有一个正整数。现要从方格中取数，使任意2 个数所在方格没有公共边，且取出的数的总和最大。试设计一个满足要求的取数算法。
对于给定的方格棋盘，按照取数要求编程找出总和最大的数。

Input

多组数据输入.
每组输入第1 行有2 个正整数m和n，分别表示棋盘的行数和列数。接下来的m行，每行有n个正整数，表示棋盘方格中的数。

Output

每组输出取数的最大总和.

Sample Input

3 3
1 2 3
3 2 3
2 3 1

Sample Output

11

题目出自nefu482，hdu1569，其中hdu1569数据较强，点数比较多。

思路：

【问题分析】

二分图点权最大独立集，转化为最小割模型，从而用最大流解决。

【建模方法】

首先把棋盘黑白染色，使相邻格子颜色不同，所有黑色格子看做二分图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 <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const   int oo=1e9;/**oo 表示无穷大*/
const  int mm=111111111;/**mm 表示边的最大数量，记住要是原图的两倍，在加边的时候都是双向的*/
const  int mn=3010;/**mn 表示点的最大数量*/
int node,src,dest,edge;/**node 表示节点数，src 表示源点，dest 表示汇点，edge 统计边数*/
int ver[mm],flow[mm],nex[mm];
int head[mn],work[mn],dis[mn],q[mn];
void prepare(int _node, int _src,int _dest)
{
    node=_node,src=_src,dest=_dest;
    for(int i=0; i<=node; ++i)head[i]=-1;
    edge=0;
}
void addedge( int u,  int v,  int c)
{
    ver[edge]=v,flow[edge]=c,nex[edge]=head[u],head[u]=edge++;
    ver[edge]=u,flow[edge]=0,nex[edge]=head[v],head[v]=edge++;
}
bool Dinic_bfs()
{
    int i,u,v,l,r=0;
    for(i=0; i<node; ++i)dis[i]=-1;
    dis[q[r++]=src]=0;
    for(l=0; l<r; ++l)
        for(i=head[u=q[l]]; i>=0; i=nex[i])
            if(flow[i]&&dis[v=ver[i]]<0)
            {
                dis[q[r++]=v]=dis[u]+1;
                if(v==dest)  return 1;
            }
    return 0;
}
int Dinic_dfs(  int u, int exp)
{
    if(u==dest)  return exp;
    for(  int &i=work[u],v,tmp; i>=0; i=nex[i])
        if(flow[i]&&dis[v=ver[i]]==dis[u]+1&&(tmp=Dinic_dfs(v,min(exp,flow[i])))>0)
        {
            flow[i]-=tmp;
            flow[i^1]+=tmp;
            return tmp;
        }
    return 0;
}
int Dinic_flow()
{
    int i,ret=0,delta;
    while(Dinic_bfs())
    {
        for(i=0; i<node; ++i)work[i]=head[i];
        while((delta=Dinic_dfs(src,oo)))ret+=delta;
    }
    return ret;
}

int a[111][111];
int fx[4][2]= {{1,0},{0,1},{-1,0},{0,-1}};
int main()
{
    int m,n;
    while(~scanf("%d%d",&m,&n))
    {
        int sum=0;
        for(int i=1; i<=m; i++)
            for(int j=1; j<=n; j++)
                scanf("%d",&a[i][j]),sum+=a[i][j];
        prepare(m*n+2,0,m*n+1);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=n; j++)
            {
                int tem=(i-1)*n+j;
                if((i+j)&1)
                    addedge(0,tem,a[i][j]);
                else
                    addedge(tem,m*n+1,a[i][j]);
                for(int k=0; k<4; k++)
                {
                    int x=i+fx[k][0],y=j+fx[k][1];
                    if(x>=1&&x<=m&&y>=1&&y<=n)
                    {
                        int tt=(x-1)*n+y;
                        if((i+j)&1)
                            addedge(tem,tt,oo);
                        else
                            addedge(tt,tem,oo);
                    }
                }
            }
        printf("%d\n",sum-Dinic_flow());
    }
    return 0;
}