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 = ;
 const int maxm = ;
 const int dx[]={,-,,};
 const int dy[]={,,,-};
 struct Node{
     int u,v,next,val;
 }edge[ maxm ];
 int head[ maxn ],cnt;
 void init(){
     cnt = ;
     memset( head,-,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 = ;
     edge[ cnt ].next = head[ b ];
     head[ b ] = cnt++;
 }

 int queue[ maxn ];
 int lev[ maxn ];
 int Dinic( int start,int end ){
     int max_flow = ;
     while( true ){
         int Head,Tail,id;
         Head = Tail = ;
         queue[ Tail++ ] = start;
         memset( lev,-,sizeof( lev ) );
         lev[ start ] = ;
         while( Head<Tail ){
             id = head[ queue[ Head++ ] ];
             while( id!=- ){
                 if( edge[ id ].val>&&lev[edge[id].v]==- ){
                     lev[edge[id].v] = lev[edge[id].u]+;
                     queue[Tail++] = edge[id].v;
                     if( edge[id].v==end ){
                         Head = Tail;
                         break;//分层完成
                     }
                 }
                 id = edge[id].next;
             }
         }//bfs构造层次网络

         if( lev[end]==- ) break;

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