[网络流24题]方格取数问题（最大流最小割）

最新推荐文章于 2020-07-22 23:25:43 发布

原创最新推荐文章于 2020-07-22 23:25:43 发布 · 696 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

27 篇文章

订阅专栏

本文介绍了一个关于棋盘取数问题的算法解决方案，通过构建网络流图并运用Dinic算法求解最大流，最终找到符合特定条件的最大数值组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

传送门
在一个有 m*n 个方格的棋盘中，每个方格中有一个正整数。现要从方格中取数，使任意 2 个数所在方格没有公共边，且取出的数的总和最大。试设计一个满足要求的取数算法。对于给定的方格棋盘，按照取数要求编程找出总和最大的数。

题解

还是有关于配对的问题，与飞行员配对有相似之处
这里写图片描述
考虑这幅图，假设我们取数的时候从红色的点取完之后，要走到相邻的绿色的点，从绿色的点出发再取数。
建图：S->黑点，容量为点权
白点->T，容量为点权
每一个黑点->取该黑点会受到影响的白点，容量为inf
假设所有的点都取，减去最小割即可

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=1001;
const int inf=1e9;

int n,m,ans1,ans2,maxflow;
struct st{
    int x,y,v;
}a[maxn];
bool cmp(st x,st y) {
    if (x.v==y.v) return x.y<y.y; return x.v>y.v;}

struct Edge{
    int next,to,dis;
}edge[maxn<<1];
int num_edge=-1,head[maxn],cur[maxn],deep[maxn];
queue <int> q;

void add_edge(int from,int to,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
void add(int x,int y,int z) {add_edge(x,y,z); add_edge(y,x,0);}

bool bfs(int s,int t)
{
    memset(deep,0x7f,sizeof(deep));
    while (!q.empty()) q.pop();
    for (int i=0; i<=n; i++) cur[i]=head[i];
    deep[s]=0; q.push(s);
    while (!q.empty())
    {
        int now=q.front(); q.pop();
        for (int i=head[now]; i!=-1; i=edge[i].next)
        {
            int to=edge[i].to;
            if (deep[to]>inf && edge[i].dis){
                deep[to]=deep[now]+1;
                q.push(to);
                if (to==t) return 1;
            }
        }
    }
    return deep[t]<inf;
}

int dfs(int now,int t,int limit)
{
    if (now==t || !limit) return limit;
    int flow=0,f;
    for (int i=cur[now]; i!=-1; i=edge[i].next)
    {
        cur[now]=i; int to=edge[i].to;
        if (deep[to]==deep[now]+1 && (f=dfs(to,t,min(limit,edge[i].dis))))
        {
            flow+=f;
            limit-=f;
            edge[i].dis-=f;
            edge[i^1].dis+=f;
            if (!limit) break;
        }
    }
    return flow;
}

void Dinic(int s,int t)
{
    while (bfs(s,t))
    {
//      for (int i=0; i<=n; i++) printf("%d ",deep[i]); printf("\n");
        maxflow+=dfs(s,t,inf);
    }
}
int id(int x,int y) {return m*(x-1)+y;}

int main()
{
    memset(head,-1,sizeof(head));
    int tot=0,ans=0,sum=0;
    scanf("%d%d",&n,&m);
    int S=0,T=n*m+1;
    for (int i=1; i<=n; i++) 
        for (int j=1; j<=m; j++) 
        {
            int num; scanf("%d",&num); sum+=num;
            if ((i+j)&1)
            {
                add(S,id(i,j),num);
                if (i-1>=1) add(id(i,j),id(i-1,j),inf);
                if (i+1<=n) add(id(i,j),id(i+1,j),inf);
                if (j-1>=1) add(id(i,j),id(i,j-1),inf);
                if (j+1<=m) add(id(i,j),id(i,j+1),inf);
            }
            else add(id(i,j),T,num);
        }
//  for (int i=0; i<=num_edge; i++) printf("%d: %d %d %d\n",i,edge[i^1].to,edge[i].to,edge[i].dis);
    n=T;
    Dinic(S,T);
    printf("%d",sum-maxflow);
    return 0;
}