HDU_3549_网络流（最大流）

Posted 2020-08-19 Jason333

Flow Problem

Time Limit: 5000/5000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 13849    Accepted Submission(s): 6609

Problem Description

Network flow is a well-known difficult problem for ACMers. Given a graph, your task is to find out the maximum flow for the weighted directed graph.

 

 

Input

The first line of input contains an integer T, denoting the number of test cases.
For each test case, the first line contains two integers N and M, denoting the number of vertexes and edges in the graph. (2 <= N <= 15, 0 <= M <= 1000)
Next M lines, each line contains three integers X, Y and C, there is an edge from X to Y and the capacity of it is C. (1 <= X, Y <= N, 1 <= C <= 1000)

 

 

Output

For each test cases, you should output the maximum flow from source 1 to sink N.

 

 

Sample Input

2

3 2

1 2 1

2 3 1

3 3

1 2 1

2 3 1

1 3 1

 

 

Sample Output

Case 1: 1

Case 2: 2

 

第一道网络流的题。

Edmonds-Karp算法：

从零流（所有边流量均为0）开始不断增加流量，保持每次增加流量后都满足流量限制、反对称性、流量平衡这3个条件。

把原图中每条边上的容量与流量之差（称为残余容量，简称残量）计算出，得到残量网络，残量网络中的边数可能达到原图中边数的两倍（详见小白书。残量网络是为了可以自我修正。假如当前增广路造成了堵塞时，若有反向边就可以修正错误。）

 

残量网络中任何一条从s到t的邮箱道路对应一条原图中的增广路，只要求出该道路中所有残量的最小值d，把对应的所有边上的流量增加d即可，这个过程称为增广。不难验证，如果增广前的流量满足3个条件，增广后仍然满足。显然，只要残量网络中存在增广路，流量就可以增大（如果残量网络中不存在增广路，则当前流就是最大流）——增广路定理

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define N 20
#define INF 100000000

int cap[N][N];
int flow[N][N];
queue<int>q;
int main()
{
    int t,cnt=0;
    scanf("%d",&t);
    while(t--)
    {
        while(!q.empty())
            q.pop();
        int n,m;
        scanf("%d%d",&n,&m);
        memset(cap,0,sizeof(cap));
        for(int i=0; i<m; i++)
        {
            int x,y,c;
            scanf("%d%d%d",&x,&y,&c);
            if(cap[x][y]!=0)
                cap[x][y]+=c;
            else
                cap[x][y]=c;
        }
        int totf=0,a[N],p[N];
        memset(flow,0,sizeof(flow));
        for(;;)
        {
            memset(a,0,sizeof(a));
            a[1]=INF;
            q.push(1);
            while(!q.empty())
            {
                int u=q.front();
                q.pop();
                for(int v=1; v<=n; v++)
                    if(!a[v]&&cap[u][v]>flow[u][v])
                    {
                        p[v]=u;
                        q.push(v);
                        if(cap[u][v]-flow[u][v]>a[u])
                            a[v]=a[u];
                        else
                            a[v]=cap[u][v]-flow[u][v];
                    }
            }
            if(a[n]==0)
                break;
            for(int u=n; u!=1; u=p[u])
            {
                flow[p[u]][u]+=a[n];
                flow[u][p[u]]-=a[n];
            }
            totf+=a[n];
        }
        printf("Case %d: %d\n",++cnt,totf);
    }
    return 0;
}