hdu 1565 方格取数(1)/hdu 1569 方格取数(2)(最小割，黑白染色)

方格取数(1)

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7856    Accepted Submission(s): 2962

Problem Description

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

 

Input

包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20)

 

Output

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

 

Sample Input

  
  

   
   3
75 15 21 
75 15 28 
34 70 5 
  
  

 

Sample Output

  
  

   
   188
  
  

 

Author

ailyanlu

 

Source

Happy 2007

 

题意：中文题不解释

思路：题目要求最大点权独立集（选出一些点使得相互之间没有已经连接的边并且点权之和最大），并且最大点权独立集=总和-最小点权覆盖集（选出一些点使得所有边至少有一个端点在点集里并且点权之和最小）=总和-最小割（把最小点权覆盖集切断即是最小割）=总和-最大流（最大流=最小割）

懂的上面这些概念此题就容易了，首先将棋盘黑白染色，然后将起点与所有白点连接，容量为白点的权值。然后将白点与黑点连接，容量为INF，黑点与汇点连接，容量为黑点权值

跑一遍最大流，然后总和减掉即可。

代码1：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define N 400
#define INF 99999999
struct Edge
{
    int v,next,cap;
} edge[N*N];
int cnt,head[N],d[N];
int ma[25][25];
int dir[4][2]= {-1,0,1,0,0,-1,0,1};
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void addedge(int u,int v,int cap)
{
    edge[cnt].v=v,edge[cnt].cap=cap;
    edge[cnt].next=head[u],head[u]=cnt++;
    edge[cnt].v=u,edge[cnt].cap=0;
    edge[cnt].next=head[v],head[v]=cnt++;
}
int bfs(int s,int t)
{
    memset(d,-1,sizeof(d));
    d[s]=0;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v,cap=edge[i].cap;
            if(d[v]==-1&&cap>0)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[t]!=-1;
}
int dfs(int s,int t,int f)
{
    if(s==t||f==0) return f;
    int flow=0;
    for(int i=head[s];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v,cap=edge[i].cap;
        if(d[v]==d[s]+1&&cap>0)
        {
            int x=min(f-flow,cap);
            x=dfs(v,t,x);
            flow+=x;
            edge[i].cap-=x;
            edge[i^1].cap+=x;
        }
    }
    if(!flow) d[s]=-2;
    return flow;
}
int Dinic(int s,int t)
{
    int flow=0,f;
    while(bfs(s,t))
    {
        while(f=dfs(s,t,INF))
            flow+=f;
    }
    return flow;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        int sum=0;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                {
                    scanf("%d",&ma[i][j]);
                    sum+=ma[i][j];
                }
        int s=0,t=n*n+1;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
            {
                if((i+j)%2==0)
                {
                    for(int k=0; k<4; k++)
                    {
                        int x=i+dir[k][0],y=j+dir[k][1];
                        if(x<1||x>n||y<1||y>n) continue;
                        addedge((i-1)*n+j,(x-1)*n+y,INF);
                    }
                    addedge(s,(i-1)*n+j,ma[i][j]);
                }
                else addedge((i-1)*n+j,t,ma[i][j]);
            }
        int ans=Dinic(s,t);
        printf("%d\n",sum-ans);
    }
    return 0;
}

代码2：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define N 2500
#define INF 99999999
struct Edge
{
    int v,next,cap;
} edge[N*N];
int cnt,head[N],d[N];
int ma[55][55];
int dir[4][2]= {-1,0,1,0,0,-1,0,1};
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
}
void addedge(int u,int v,int cap)
{
    edge[cnt].v=v,edge[cnt].cap=cap;
    edge[cnt].next=head[u],head[u]=cnt++;
    edge[cnt].v=u,edge[cnt].cap=0;
    edge[cnt].next=head[v],head[v]=cnt++;
}
int bfs(int s,int t)
{
    memset(d,-1,sizeof(d));
    d[s]=0;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v,cap=edge[i].cap;
            if(d[v]==-1&&cap>0)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[t]!=-1;
}
int dfs(int s,int t,int f)
{
    if(s==t||f==0) return f;
    int flow=0;
    for(int i=head[s];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v,cap=edge[i].cap;
        if(d[v]==d[s]+1&&cap>0)
        {
            int x=min(f-flow,cap);
            x=dfs(v,t,x);
            flow+=x;
            edge[i].cap-=x;
            edge[i^1].cap+=x;
        }
    }
    if(!flow) d[s]=-2;
    return flow;
}
int Dinic(int s,int t)
{
    int flow=0,f;
    while(bfs(s,t))
    {
        while(f=dfs(s,t,INF))
            flow+=f;
    }
    return flow;
}
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        init();
        int sum=0;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=m; j++)
                {
                    scanf("%d",&ma[i][j]);
                    sum+=ma[i][j];
                }
        int s=0,t=n*m+1;
        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 x=i+dir[k][0],y=j+dir[k][1];
                        if(x<1||x>n||y<1||y>m) continue;
                        addedge((i-1)*m+j,(x-1)*m+y,INF);
                    }
                    addedge(s,(i-1)*m+j,ma[i][j]);
                }
                else addedge((i-1)*m+j,t,ma[i][j]);
            }
        int ans=Dinic(s,t);
        printf("%d\n",sum-ans);
    }
    return 0;
}