HDU 1569 方格取数(2)（最小割）

方格取数(2)

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 5256    Accepted Submission(s): 1652

Problem Description

给你一个m*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取数所在的2个格子不能相邻，并且取出的数的和最大。

 

Input

包括多个测试实例，每个测试实例包括2整数m,n和m*n个非负数(m<=50,n<=50)

 

Output

对于每个测试实例，输出可能取得的最大的和

 

Sample Input

  
  

   
   3 3
75 15 21 
75 15 28 
34 70 5
  
  

 

Sample Output

  
  

   
   188
  
  

 

Author

ailyanlu

 

Source

Happy 2007

 

解题：求最大可取的和，可以先过来求最小不能取的和，再用所有数的和 相减 就是答案。求最小不能取的和用最小割，因不能取相邻的数，所以可以分成奇偶两个部分，再拆点，拆点后的边容为点值。偶部分的点与源点相连，边容INF，偶到奇相连，边容INF，奇到汇点，边容INF。

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define captype int

const int MAXN = 40010;   //点的总数
const int MAXM = 400010;    //边的总数
const int INF = 1<<30;
struct EDG{
    int to,next;
    captype cap;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN];  //每种距离(或可认为是高度)点的个数
int dis[MAXN];  //每个点到终点eNode 的最短距离
int cur[MAXN];  //cur[u] 表示从u点出发可流经 cur[u] 号边

void init(){
    eid=0;
    memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void addEdg(int u,int v,captype c,captype rc=0){
    edg[eid].to=v; edg[eid].next=head[u];
    edg[eid].cap=c; head[u]=eid++;

    edg[eid].to=u; edg[eid].next=head[v];
    edg[eid].cap=rc; head[v]=eid++;
}
//预处理eNode点到所有点的最短距离
void BFS(int sNode, int eNode){
    queue<int>q;
    memset(gap,0,sizeof(gap));
    memset(dis,-1,sizeof(dis));
    gap[0]=1;
    dis[eNode]=0;
    q.push(eNode);
    while(!q.empty()){
        int u=q.front(); q.pop();
        for(int i=head[u]; i!=-1; i=edg[i].next){
            int v=edg[i].to;
            if(dis[v]==-1){
                dis[v]=dis[u]+1;
                gap[dis[v]]++;
                q.push(v);
            }
        }
    }
}
int S[MAXN];    //路径栈，存的是边的id号
captype maxFlow_sap(int sNode,int eNode, int n){  //注意：n为点的总个数，包括源点与汇点
    BFS(sNode, eNode);              //预处理eNode到所有点的最短距离
    if(dis[sNode]==-1) return 0;    //源点到不可到达汇点
    memcpy(cur,head,sizeof(head));

    int top=0;  //栈顶
    captype ans=0;  //最大流
    int u=sNode;
    while(dis[sNode]<n){   //判断从sNode点有没有流向下一个相邻的点
        if(u==eNode){   //找到一条可增流的路
            captype Min=INF ;
            int inser;
            for(int i=0; i<top; i++)    //从这条可增流的路找到最多可增的流量Min
            if(Min>=edg[S[i]].cap){
                Min=edg[S[i]].cap;
                inser=i;
            }
            for(int i=0; i<top; i++){
                edg[S[i]].cap-=Min;
                edg[S[i]^1].cap+=Min;  //可回流的边的流量
            }
            ans+=Min;
            top=inser;  //从这条可增流的路中的流量瓶颈 边的上一条边那里是可以再增流的，所以只从断流量瓶颈 边裁断
            u=edg[S[top]^1].to;  //流量瓶颈 边的起始点
            continue;
        }
        bool flag = false;  //判断能否从u点出发可往相邻点流
        int v;
        for(int i=cur[u]; i!=-1; i=edg[i].next){
            v=edg[i].to;
            if(edg[i].cap>0 && dis[u]==dis[v]+1){
                flag=true;
                cur[u]=i;
                break;
            }
        }
        if(flag){
            S[top++] = cur[u];  //加入一条边
            u=v;
            continue;
        }
        //如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
        int Mind= n;
        for(int i=head[u]; i!=-1; i=edg[i].next)
        if(edg[i].cap>0 && Mind>dis[edg[i].to]){
            Mind=dis[edg[i].to];
            cur[u]=i;
        }
        gap[dis[u]]--;
        if(gap[dis[u]]==0) return ans;  //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
                                        //因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
        dis[u]=Mind+1;      //如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
        gap[dis[u]]++;
        if(u!=sNode) u=edg[S[--top]^1].to;  //退一条边

    }
    return ans;
}
int main(){
    int n,m,mapt[55][55];
    int dir[4][2]={0,1,0,-1,1,0,-1,0};
    while(scanf("%d%d",&n,&m)>0){
        init();
        int ans=0;
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++){
                scanf("%d",&mapt[i][j]);
                ans+=mapt[i][j];
            }

        int s=0 , t=n*m*2+1;
        for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
        if((i+j)%2==0){
            addEdg(s , i*m+j+1, INF);
            addEdg(i*m+j+1 , i*m+j+1+n*m , mapt[i][j]);
            for(int e=0; e<4; e++){
                int ti=i+dir[e][0];
                int tj=j+dir[e][1];
                if(ti>=0&&ti<n&&tj>=0&&tj<m)
                    addEdg(i*m+j+1+n*m , ti*m+tj+1, INF);
            }
        }
        else{
            addEdg(i*m+j+1 , i*m+j+1+n*m , mapt[i][j]);
            addEdg(i*m+j+1+n*m , t , INF);
        }
        ans-=maxFlow_sap(s , t ,t+1);
        printf("%d\n",ans);
    }
}