hdu 1565 方格取数 最大点权独立集

方格取数(1)

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

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

 

 

纯粹的最大点权独立集，适合初学者

#include<iostream>
#include<queue>
#include<cstring>
#include<cstdio>
#include<climits>
#define MAXE 2000
#define MAXP 410
#define Max(a,b) a>b?a:b
#define Min(a,b) a<b?a:b
using namespace std;
struct Edge
{
    int s,t,f,next;
}edge[MAXE];
int head[MAXP];
int cur[MAXP];
int pre[MAXP];
int stack[MAXE];
int ent;
int sum;
int n,m,s,t;
int num;
void add(int start,int last,int f)
{
    edge[ent].s=start;edge[ent].t=last;edge[ent].f=f;edge[ent].next=head[start];head[start]=ent++;
    edge[ent].s=last;edge[ent].t=start;edge[ent].f=0;edge[ent].next=head[last];head[last]=ent++;
}
bool bfs(int S,int T)
{
    memset(pre,-1,sizeof(pre));
    pre[S]=0;
    queue<int>q;
    q.push(S);
    while(!q.empty())
    {
        int temp=q.front();
        q.pop();
        for(int i=head[temp];i!=-1;i=edge[i].next)
        {
            int temp2=edge[i].t;
            if(pre[temp2]==-1&&edge[i].f)
            {
                pre[temp2]=pre[temp]+1;
                q.push(temp2);
            }
        }
    }
    return pre[T]!=-1;
}
int dinic(int start,int last)
{
    int flow=0,now;
    while(bfs(start,last))
    {
        int top=0;
        memcpy(cur,head,sizeof(head));
        int u=start;
        while(1)
        {
            if(u==last)//如果找到终点结束对中间路径进行处理并计算出该流
            {
                int minn=INT_MAX;
                for(int i=0;i<top;i++)
                {
                    if(minn>edge[stack[i]].f)
                    {
                        minn=edge[stack[i]].f;
                        now=i;
                    }
                }
                flow+=minn;
                for(int i=0;i<top;i++)
                {
                    edge[stack[i]].f-=minn;
                    edge[stack[i]^1].f+=minn;
                }
                top=now;
                u=edge[stack[top]].s;
            }
            for(int i=cur[u];i!=-1;cur[u]=i=edge[i].next)//找出从u点出发能到的边
                if(edge[i].f&&pre[edge[i].t]==pre[u]+1)
                    break;
            if(cur[u]==-1)//如果从该点未找到可行边，将该点标记并回溯
            {
                if(top==0)break;
                pre[u]=-1;
                u=edge[stack[--top]].s;
            }
            else//如果找到了继续运行
            {
                stack[top++]=cur[u];
                u=edge[cur[u]].t;
            }
        }
    }
    return flow;
}
int main()
{
    while(~scanf("%d",&n))
    {
        s=0;t=n*n+1;
        sum=0;
        memset(head,-1,sizeof(head));
        ent=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%d",&num);
                sum+=num;
                if((i+j)%2)
                {
                    add(i*n+j+1,t,num);
                }
                else
                {
                    add(s,i*n+j+1,num);
                    if(i!=0)
                        add(i*n+j+1,(i-1)*n+j+1,INT_MAX);
                    if(j!=0)
                        add(i*n+j+1,i*n+j,INT_MAX);
                    if(i!=n-1)
                        add(i*n+j+1,(i+1)*n+j+1,INT_MAX);
                    if(j!=n-1)
                        add(i*n+j+1,i*n+j+2,INT_MAX);
                }
            }
        }
        printf("%d
",sum-dinic(s,t));
    }
    return 0;
}