UESTC 1143 传输数据 网络流 最大流 Dinic

传输数据

Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

Submit  Status

机房里面有 m 台电脑， n 台网线，每条网线都每秒中最多传送的数据量，现在需要你计算从标号为1的电脑传送数据到编号为 m 的电脑，问一秒内

最多传送多少数据?

Input

第1行: 两个用空格分开的整数 N(0≤N≤200) 和  M(2≤M≤200) 。 N 网线的数量， M 是电脑的数量。

第二行到第 N+1 行: 每行有三个整数， Si ， Ei  和  Ci 。 Si  和  Ei   (1≤Si,Ei≤M)   指明电脑编号，数据从  Si 流向  Ei 。

Ci(0≤Ci≤10,000,000)      是这条网线的最大容量。

Output

输出一个整数，即排水的最大流量。

Sample input and output

Sample Input	Sample Output
5 4 1 2 40 1 4 20 2 4 20 2 3 30 3 4 10	50

Source

2015 UESTC Training for Graph Theory

The question is from   here.

My Solution

最大流的Dinic算法  O(N^2 *M)   N vertices and M edges

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int inf = 1000000000;
const int maxn = 200, maxm = 200;         //the max number of vertices and edges

struct Edge
{
    int v, f, nxt;
};

int n, src, sink;
int g[maxn+8];
int nume;
Edge e[maxm*2+8];

void addedge(int u, int v, int c)
{
    e[++nume].v = v;
    e[nume].f = c;
    e[nume].nxt = g[u];
    g[u] = nume;
    e[++nume].v = u;
    e[nume].f = 0;
    e[nume].nxt = g[v];
    g[v] = nume;
}

void init()
{
    memset(g, 0, sizeof(g));
    nume = 1;
}

queue<int> que;
bool vis[maxn+8];
int dist[maxn+8];    //distance

void bfs()
{
    memset(dist, 0, sizeof(dist));
    while(!que.empty()) que.pop();
    vis[src] = true;
    que.push(src);
    while(!que.empty()){
        int u = que.front();
        que.pop();
        for(int i = g[u]; i; i = e[i].nxt) {
            if(e[i].f && !vis[e[i].v]) {
                que.push(e[i].v);
                dist[e[i].v] = dist[u] + 1;
                vis[e[i].v] = true;
            }
        }
    }
}

int dfs(int u, int delta)
{
    if(u == sink){
        return delta;
    }
    else{
        int ret = 0;
        for(int i = g[u]; delta && i; i = e[i].nxt) {
            if(e[i].f && dist[e[i].v] == dist[u] + 1) {
                int dd = dfs(e[i].v, min(e[i].f, delta));
                e[i].f -= dd;
                e[i^1].f += dd;
                delta -= dd;
                ret += dd;
            }
        }
        return ret;
    }
}

int maxflow()
{
    int ret = 0;
    while(true) {
        memset(vis, 0, sizeof(vis));
        bfs();
        if(!vis[sink]) return ret;
        ret += dfs(src, inf);
    }
}

int main()
{
    int N, M, S, E, C;
    scanf("%d%d", &N, &M);
    src = 1;sink = M;
    while(N--){
        scanf("%d%d%d", &S, &E, &C);
        addedge(S, E, C);
    }
    printf("%d", maxflow());
    return 0;
}

Thank you!