HDU_1569 方格取数(2) 最小割

http://acm.hdu.edu.cn/showproblem.php?pid=1569

题意：

给定一个N*N的矩阵，矩阵的每个位置都存放着一个非负的数，现在要你从其中选出

若干个数，并且所选的每两个数的不能有公共边，问最大的和是多少。 N,M<=50。

思路：

思路一：我们一开始想到的一种思路是dp，因为我们可以发现，每一行能不能选只取

决于它的上一行状态，因此在确定第i行状态的时候，我们只需要记录第i-1的状态就可

以了。因此我们可以得出以下的dp方程：F(i ,j) 表示选完第i行之后，第i行的状态为j的

最大和。状态转移方程为：F(i, j ) = sum{ F(i-1, k) + add_sum } ;但是这样的思路在N,M

<=50的情况下是肯定会超时的，因此这种思路在本题上是错误的。

思路二：我们设想我们只需要将所有的点分成两部分：一部分是选的，一部分是不选的

就可以了，这样就让我们想到了最小割定理，首先我们将所有结点分成两个不同的集合

A、B，按照黑白染色的原理，将所有点分成两个部分，引入一个超级源点和一个超级

汇点，由源点向A集合中的每个点引一条边，权值为该点的值，由B集合向汇点引一条

边，权值也为该点的值，然后对于相邻的两个点，由A集合中的点向B集合中的点引一

条inf的边，这样做的原因是避免相邻的两个点都被选，建完图之后跑一个sap就可以出

解了。

代码：

#include<stdio.h>
#include<string.h>
#define CC(m, what ) memset(m , what, sizeof(m))
const int inf = (1<<30) ;
const int MAXN = 55*55 ;
int M, N ,S ,T, NV ;

int val[55][55] ;
struct Node{
    int c , next , num ;
}E[2500*10] ;
int head[2600] , NE ;
int dr[4] = {-1,1,0,0} ;
int dc[4] = {0,0,-1,1} ;

void add(int u , int v ,int c ,int cc=0){
    E[NE].c = c ; E[NE].next = head[u] ; E[NE].num = v ; head[u] = NE++ ;
    E[NE].c = cc ; E[NE].next = head[v] ; E[NE].num = u ; head[v] = NE++ ;
}
void build(){
    CC(head, -1) ; NE = 0 ;

    for(int i=1;i<=M;i++){
        for(int j=1;j<=N;j++){
            if( (i+j)&1 ){
                add( S , (i-1)*N+j , val[i][j]);
                for(int k=0;k<4;k++){
                    int rr = i + dr[k] ;
                    int cc = j + dc[k] ;
                    if(rr<1||rr>M||cc<1||cc>N)  continue ;
                    add( (i-1)*N+j , (rr-1)*N+cc , inf );
                }
            }
            else{
                add( (i-1)*N+j , T, val[i][j] );
            }

        }
    }
}
int gap[MAXN] , dis[MAXN] , cur[MAXN]  ,pre[MAXN];
void checkmin(int &a, int b){
    a = a > b ? b : a ;
}
int sap(){
    CC(gap, 0) ; CC(dis, 0) ;
    for(int i=0;i<NV;i++)   cur[i] = head[i] ;
    int u = pre[S] = S ; gap[0] = NV ;
    int aug = inf ,maxflow = 0 ;
    while( dis[S] < NV ){
loop :
        for(int &i=cur[u] ;i!=-1; i=E[i].next){
            int v = E[i].num ;
            if( E[i].c && dis[u]==dis[v]+1){
                pre[v] = u ;
                u = v ;
                checkmin( aug, E[i].c );
                if(v == T){
                    maxflow += aug ;
                    for(u=pre[u] ;v!=S;v=u,u=pre[u]){
                        E[ cur[u] ].c -= aug ;
                        E[ cur[u]^1 ].c += aug ;
                    }
                    aug = inf ;
                }
                goto loop ;
            }
        }
        int mindis = NV ;
        for(int i=head[u] ;i!=-1;i=E[i].next){
            int v = E[i].num ;
            if( E[i].c && mindis > dis[v] ){
                mindis = dis[v] ;
                cur[u] = i ;
            }
        }
        if( (--gap[dis[u]])== 0)    break ;
        gap[ dis[u] = mindis + 1 ]++ ;
        u = pre[u] ;
    }
    return maxflow ;
}

int main(){
    while(scanf("%d%d",&M,&N) == 2){
        int sum = 0 ;
        for(int i=1;i<=M;i++){
            for(int j=1;j<=N;j++){
                scanf("%d",&val[i][j]);
                sum += val[i][j] ;
            }
        }
        S = 0 ; T = M * N + 1 ;
        NV = T + 1 ;
        build() ;
        printf("%d\n",sum-sap());
    }
    return 0 ;
}