#1369 : 网络流一·Ford-Fulkerson算法

10000ms

1000ms

256MB

描述

小Hi和小Ho住在P市，P市是一个很大很大的城市，所以也面临着一个大城市都会遇到的问题：交通拥挤。

小Ho：每到周末回家感觉堵车都是一种煎熬啊。

小Hi：平时交通也还好，只是一到上下班的高峰期就会比较拥挤。

小Ho：要是能够限制一下车的数量就好了，不知道有没有办法可以知道交通系统的最大承受车流量，这样就可以限制到一个可以一直很顺畅的数量了。

小Hi：理论上是有算法的啦。早在1955年，T.E.哈里斯就提出在一个给定的网络上寻求两点间最大运输量的问题。并且由此产生了一个新的图论模型：网络流。

小Ho：那具体是啥？

小Hi：用数学的语言描述就是给定一个有向图G=(V,E)，其中每一条边(u,v)均有一个非负数的容量值，记为c(u,v)≥0。同时在图中有两个特殊的顶点，源点S和汇点T。

举个例子：

其中节点1为源点S，节点6为汇点T。

我们要求从源点S到汇点T的最大可行流量，这个问题也被称为最大流问题。

在这个例子中最大流量为5，分别为：1→2→4→6，流量为1；1→3→4→6，流量为2；1→3→5→6，流量为2。

小Ho：看上去好像挺有意思的，你让我先想想。

​​提示：Ford-Fulkerson算法​​

输入

第1行：2个正整数N,M。2≤N≤500，1≤M≤20,000。

第2..M+1行：每行3个整数u,v,c(u,v)，表示一条边(u,v)及其容量c(u,v)。1≤u,v≤N，0≤c(u,v)≤100。

给定的图中默认源点为1，汇点为N。可能有重复的边。

输出

第1行：1个整数，表示给定图G的最大流。

样例输入

6 7
1 2 3
1 3 5
2 4 1
3 4 2
3 5 3
4 6 4
5 6 2

样例输出

5

网络流最基本最裸的模板。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>

#define REP(I, X) for(int I = 0; I < X; ++I)
#define FF(I, A, B) for(int I = A; I <= B; ++I)
#define clear(A, B) memset(A, B, sizeof A)
#define copy(A, B) memcpy(A, B, sizeof A)
#define min(A, B) ((A) < (B) ? (A) : (B))
#define max(A, B) ((A) > (B) ? (A) : (B))
using namespace std;
typedef long long ll;
typedef long long LL;
const int oo = 0x3f3f3f3f;
const int maxE = 1100050;
const int maxN = 10005;
const int maxQ = 1100050;
struct Edge{
    int v, n;
    long long c;

};


Edge edge[maxE];
int adj[maxN], cntE;
int Q[maxQ], head, tail, inq[maxN];
int d[maxN], num[maxN], cur[maxN], pre[maxN];
int s, t, nv;
int n, m, nm;
int path[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void addedge(int u, int v, long long c){
    edge[cntE].v = v;edge[cntE].c = c; edge[cntE].n = adj[u]; adj[u] = cntE++;
    edge[cntE].v = u;edge[cntE].c = 0; edge[cntE].n = adj[v]; adj[v] = cntE++;
}
void REV_BFS(){
    clear(d, -1);
    clear(num, 0);
    head = tail = 0;
    d[t] = 0;
    num[0] = 1;
    Q[tail++] = t;
    while(head != tail){
        int u = Q[head++];
        for(int i = adj[u]; ~i; i = edge[i].n){
            int v = edge[i].v;
            if(~d[v]) continue;
            d[v] = d[u] + 1;
            num[d[v]]++;
            Q[tail++] = v;
        }
    }
}

long long ISAP(){
    copy(cur, adj);
    REV_BFS();
    int  u = pre[s] = s, i;
    long long flow=0;
    while(d[s] < nv){
        if(u == t){
            long long f = oo, neck;
            for(i = s; i != t; i = edge[cur[i]].v){
                if(f > edge[cur[i]].c){
                    f = edge[cur[i]].c;
                    neck = i;
                }
            }
            for(i = s; i != t; i = edge[cur[i]].v){
                edge[cur[i]].c -= f;
                edge[cur[i] ^ 1].c += f;
            }
            flow += f;
            u = neck;
        }
        for(i = cur[u]; ~i; i = edge[i].n) if(edge[i].c && d[u] == d[edge[i].v] + 1) break;
        if(~i){
            cur[u] = i;
            pre[edge[i].v] = u;
            u = edge[i].v;
        }
        else{
            if(0 == (--num[d[u]])) break;
            int mind = nv;
            for(i = adj[u]; ~i; i = edge[i].n){
                if(edge[i].c && mind > d[edge[i].v]){
                    mind = d[edge[i].v];
                    cur[u] = i;
                }
            }
            d[u] = mind + 1;
            num[d[u]]++;
            u = pre[u];
        }
    }
    return flow;
}

int read () {
    char c = ' ' ;
    int x = 0 ;
    while ( c < '0' || c > '9' )
        c = getchar () ;
    while ( c >= '0' && c <= '9' ) {
        x = x * 10 + c - '0' ;
        c = getchar () ;
    }
    return x ;
}


void work()
{
    cntE=0;
    clear(adj, -1);
    int u,v,w;
    int sum=0;
    s = 1 , t = n, nv = t + 1 ;
    for(int i=1;i<=m;i++){
        u = read () ;v = read () ;w = read () ;
        sum+=u;
        addedge ( u , v , w ) ;

    }
    LL flow =ISAP();

    printf ( "%lld\n",flow) ;


}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        work();
    }
    return 0;
}