A+B problem （网络流）

最新推荐文章于 2021-11-18 20:22:59 发布

原创最新推荐文章于 2021-11-18 20:22:59 发布 · 550 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了一种基于C++的网络流算法实现，通过使用队列、深度优先搜索和广度优先搜索等数据结构和算法，实现了从源点到汇点的最大流量计算。文章深入探讨了算法的细节，包括如何读取输入数据、处理边的容量以及更新残余网络。

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

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
inline int read()
{
    int x=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if(c=='-')  f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        x=x*10+c-'0';
        c=getchar();
    }
    return f*x;
}
const int N=1e2+5,MAX=2147483647;
int a,b,ans,dis[N],cur[N],s=1,t=100;
int had[N],to[N*2],cap[N*2],nxt[N*2],p=1;
void deal(int &x)
{
    if(x<0)  {
        ans+=x*2;
        x=-x;
    }
}
void add(int x,int y,int z)
{
    nxt[++p]=had[x];
    to[p]=y;
    cap[p]=z;
    had[x]=p;
}
bool bfs(int s,int t)
{
    dis[t]=0;
    queue <int> que;
    que.push(s);  dis[s]=1;
    while(que.size())  {
        int u=que.front();
        que.pop();  cur[u]=had[u];
        for(int i=had[u];i;i=nxt[i])  {
            int v=to[i];
            if(dis[v]||!cap[i])  continue;
            dis[v]=dis[u]+1;
            que.push(v);
        }
    }
    return dis[t]!=0;
}
int dfs(int u,int t,int lim)
{
    if(u==t)  return lim;
    int flow=0;
    for(int i=cur[u];i;i=nxt[i])  {
        int v=to[i];
        cur[u]=i;
        if(dis[v]==dis[u]+1&&cap[i])  {
            int x=dfs(v,t,min(cap[i],lim-flow));
            cap[i]-=x;
            cap[i^1]+=x;
            flow+=x;
            if(flow==lim)  break;
        }
    }
    if(!flow)  dis[u]=-1;
    return flow;
}
int main()
{
    a=read();  b=read();
    deal(a);  deal(b);
    add(s,t,a);  add(t,s,0);
    add(s,t,b);  add(t,s,0);
    while(bfs(s,t))  {
        ans+=dfs(s,t,MAX);
    }
    printf("%d",ans);
    return 0;
}