HDU3549 - Flow Problem(模板网络流 + Ford-Fulkerson算法)

Flow Problem

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

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
  
  

 

Author

HyperHexagon

 

Source

HyperHexagon's Summer Gift (Original tasks)

经典的网络流题目

#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <vector>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;


#define pb push_back
#define mp make_pair
#define fillchar(a, x) memset(a, x, sizeof(a))
#define copy(a, b) memcpy(a, b, sizeof(a))
#define lson rt << 1, l, mid
#define rson rt << 1|1, mid + 1, r


typedef long long LL;
typedef pair<int, int > PII;
typedef unsigned long long uLL;
template<typename T>
void print(T* p, T* q, string Gap = " ") {
    int d = p < q ? 1 : -1;
    while(p != q) {
        cout << *p;
        p += d;
        if(p != q) cout << Gap;
    }
    cout << endl;
}
template<typename T>
void print(const T &a, string bes = "") {
    int len = bes.length();
    if(len >= 2)cout << bes[0] << a << bes[1] << endl;
    else cout << a << endl;
}

const int INF = 0x3f3f3f3f;
const int MAXM = 2e5;
const int MAXN = 1000 + 5;

struct edge{
    int to, cap, rev;//终点 容量 反向边
};

vector<edge> G[MAXN];
bool used[MAXN];

void add_edge(int from, int to, int cap){
    G[from].push_back((edge){to, cap, G[to].size()});
    G[to].push_back((edge){from, 0, G[from].size() - 1});
}

int dfs(int v, int t, int f){
    if(v == t) return f;
    used[v] = true;
    for(int i = 0;i < G[v].size();i ++){
        edge &e = G[v][i];
        if(!used[e.to] && e.cap > 0){//在增广路径中，每一次查询中，只能访问一次
            int d = dfs(e.to, t, min(f, e.cap));//寻找当前满足条件的增广路径
            if(d > 0){
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}


int max_flow(int s, int t){
    int flow = 0;
    for(;;){
        memset(used, 0, sizeof(used));
        int f = dfs(s, t, INF);//每次进行增广路径的查询
        if(f == 0) return flow;
        flow += f;
    }
}

int T, N, M;
int X, Y, C;
int main(){
    int cnt = 1;
    scanf("%d", &T);
    while(T --){
        scanf("%d%d", &N, &M);
        for(int i = 1;i <= N;i ++){
            G[i].clear();
        }
        for(int i = 0;i < M;i ++){
            scanf("%d%d%d", &X, &Y, &C);
            add_edge(X, Y, C);
        }
        printf("Case %d: %d\n", cnt ++, max_flow(1, N));
    }
    return 0;
}