HDU1569+最大点权集

/*
最大点权独立集=总权值-最小点权覆盖集
最大点权独立集=最大流
最小点权覆盖集=最小割

题意：
给你一个m*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取数所在的2个格子不能相邻，并且取出的数的和最大。
根据奇偶建立二分图，
if(i+j)%2==0 源点和该点连接,权值为该点的点权,
if(i+j)%2==1 该点和汇点连接,权值为该点的点权,
之后若i+j为偶数的点和i+j为奇数的点之间相邻，那么就连一条从为偶数的点到为奇数的点的边，权值为无穷大
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<math.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2605;
const int maxm = 30005;
const int dx[]={1,-1,0,0};
const int dy[]={0,0,1,-1};
struct Node{
    int u,v,next,val;
}edge[ maxm ];
int head[ maxn ],cnt;
void init(){
    cnt = 0;
    memset( head,-1,sizeof( head ) );
}
void addedge( int a,int b,int c ){
    edge[ cnt ].u = a;
    edge[ cnt ].v = b;
    edge[ cnt ].val = c;
    edge[ cnt ].next = head[ a ];
    head[ a ] = cnt++;
    
    edge[ cnt ].u = b;
    edge[ cnt ].v = a;
    edge[ cnt ].val = 0;
    edge[ cnt ].next = head[ b ];
    head[ b ] = cnt++;
}

int queue[ maxn ];
int lev[ maxn ];
int Dinic( int start,int end ){
    int max_flow = 0;
    while( true ){
        int Head,Tail,id;
        Head = Tail = 0;
        queue[ Tail++ ] = start;
        memset( lev,-1,sizeof( lev ) );
        lev[ start ] = 0;
        while( Head<Tail ){
            id = head[ queue[ Head++ ] ];
            while( id!=-1 ){
                if( edge[ id ].val>0&&lev[edge[id].v]==-1 ){
                    lev[edge[id].v] = lev[edge[id].u]+1;
                    queue[Tail++] = edge[id].v;
                    if( edge[id].v==end ){
                        Head = Tail;
                        break;//分层完成
                    }
                }
                id = edge[id].next;
            }
        }//bfs构造层次网络
        
        if( lev[end]==-1 ) break;
        
        id = start;
        Tail = 0;
        //这里queue被当作stack来用
        while( true ){//层次网络中进行dfs
            if( id==end ){//dfs找到汇点
                int flow = inf;
                int flag = -1;
                for( int i=0;i<Tail;i++ ){
                    if( edge[queue[i]].val<flow ){
                        flow = edge[queue[i]].val;
                        flag = i;
                    }
                }//寻找最小的边
                for( int i=0;i<Tail;i++ ){
                    edge[ queue[i] ].val -= flow;
                    edge[ queue[i]^1 ].val += flow;
                }
                if( flag!=-1 )
                {
                    max_flow += flow;
                    Tail = flag;
                    id = edge[ queue[flag] ].u;
                }
                else
                    return inf;
            }
            id = head[ id ];
            while( id!=-1 ){
                if( edge[id].val>0&&(lev[edge[id].u]+1==lev[edge[id].v]) ){
                    break;
                }
                id = edge[id].next;
            }
            if( id!=-1 ){
                queue[Tail++] = id;
                id = edge[id].v;
            }
            else{
                if( Tail==0 ) break;
                lev[ edge[queue[Tail-1]].v ] = -1;
                id = edge[queue[--Tail]].u;
            }
        }
    }
    return max_flow;
}
int main(){
    int m,n;
    while( scanf("%d%d",&n,&m)!=EOF ){
        init();
        int sum = 0;
        int temp;
        for( int i=1;i<=n;i++ ){
            for( int j=1;j<=m;j++ ){
                scanf("%d",&temp);
                if( (i+j)%2==0 ){
                    addedge( 0,(i-1)*m+j,temp );
                }
                else{
                    addedge( (i-1)*m+j,n*m+1,temp );
                }
                sum += temp;
            }
        }
        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 tx = i+dx[k];
                        int ty = j+dy[k];
                        if( tx>=1&&tx<=n&&ty>=1&&ty<=m ){
                            addedge( (i-1)*m+j,(tx-1)*m+ty,inf );
                        }
                    }
                }
            }
        }
        int start = 0;
        int end = n*m+1;
        int ans = Dinic( start,end );
        //printf("sum = %d,ans = %d
",sum,ans);
        printf("%d
",sum-ans);
    }
    return 0;
}