POJ-1273-Drainage Ditches（最大流）dinic实现后续模板待补充

本文介绍了一种高效的网络流算法——DINIC算法，并提供了详细的代码实现。该算法通过构建残余网络并利用广度优先搜索和深度优先搜索来寻找增广路径，从而求解最大流问题。

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

Sample Input

Sample Output

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <bitset>
#include <algorithm>
#include <climits>
using namespace std;
#define MAXN 1005
#define INF 0x3f3f3f3f
/*
int maze[MAXN][MAXN];
int gap[MAXN],dis[MAXN],pre[MAXN],cur[MAXN];
int sap(int start, int end, int nodenum)
{
    memset(cur,0,sizeof(cur));
    memset(dis,0,sizeof(dis));
    memset(gap,0,sizeof(gap));
    int u=pre[start]=start, maxflow=0,aug=-1;
    gap[0]=nodenum;
    while(dis[start]<nodenum)
    {
loop:
        for(int v=cur[u]; v<nodenum; ++v)
            if(maze[u][v]&&dis[u]==dis[v]+1)
            {
                if(aug==-1 ||aug>maze[u][v])aug=maze[u][v];
                pre[v]=u;
                u=cur[u]=v;
                if(v==end)
                {
                    maxflow+=aug;
                    for(u=pre[u]; v!=start; v=u,u=pre[u])
                    {
                        maze[u][v]-=aug;
                        maze[v][u]+=aug;
                    }
                    aug=-1;
                }
                goto loop;
            }
        int mindis=nodenum-1;
        for(int v=0; v<nodenum; ++v)
            if(maze[u][v]&&mindis>dis[v])
            {
                cur[u]=v;
                mindis=dis[v];
            }
        if((--gap[dis[u]])==0)break;
        gap[ dis[u]=mindis+1 ]++;
        u=pre[u];
    }
    return maxflow;
}*/
int head[MAXN],index;
struct node
{
    int v,next,val;
}eage[MAXN];
void add_eage(int a,int b,int val)
{
    eage[index].v=b;
    eage[index].val=val;
    eage[index].next=head[a];
    head[a]=index++;
}
int deep[MAXN];
bool bfs(int start,int end)
{
    int i,j;
    memset(deep,0,sizeof(deep));
    deep[start]=1;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(start);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        if(u==end)return 1;
        for(i=head[u]; i!=-1; i=eage[i].next)
        {
            int v=eage[i].v;
            if(!deep[v] && eage[i].val>0)
            {
                deep[v]=deep[u]+1;
                q.push(v);
            }
        }
    }
    return 0;
}
int DFS(int start, int max_, int end)
{
    if(start==end)return max_;
    int i,ans=0,f;
    for(i=head[start]; i!=-1 && ans<max_; i=eage[i].next)
    {
        int v=eage[i].v;
        if(deep[start]+1==deep[v] && eage[i].val>0)
        {
            f=DFS(v,min(max_-ans,eage[i].val),end);
            eage[i].val-=f;
            eage[i^1].val+=f;
            ans+=f;
            if(ans==max_)return ans;
        }
    }
    //if(!ans)deep[start]=-2;
    return ans;
}
int DINIC(int start,int end)
{
    int ans=0,t;
    while(bfs(start,end))
        while(t=DFS(start,INF,end))
        ans+=t;
    return ans;
}
int main()
{
    int m,n,a,b,v;
    while(~scanf("%d%d",&m,&n))
    {
        index=0;
        memset(head,-1,sizeof(head));
        for(int i=0; i<m; ++i)
        {
            scanf("%d%d%d",&a,&b,&v);
            add_eage(a,b,v);
            add_eage(b,a,0);
        }
        cout<<DINIC(1,n)<<endl;
    }
    return 0;
}