POJ 1273 Drainage Ditches 网络流最大流

#include <iostream>
#include <queue>
#include <climits>
#include <cstring>
using namespace std;

const int MAX_SIZE = 210;

int capacity[MAX_SIZE][MAX_SIZE];
int parent[MAX_SIZE];
bool visit[MAX_SIZE];

int vertex_num;
int edge_num;


bool Edmonds_Karp( int start, int end ){
    
    queue< int > Q;
    
    memset( visit, false, sizeof( visit ) );
    
    visit[start] = true;
    Q.push( start );
    
    while( !Q.empty() ){
        
        int temp = Q.front();
        Q.pop();
        
        for( int i = 1; i <= vertex_num; ++i ){
            
            if( capacity[temp][i] && !visit[i] ){
                
                visit[i]  = true;
                parent[i] = temp;
                Q.push( i );
                
                if( i == end ) 
                    return true;
                
            }
        }
    }
    
    return false;
}


int Ford_Fulkerson( int start, int end ){
    
    int max_flow = 0;
    
    while( true ){
        
        if( !Edmonds_Karp( start, end ) ) 
            break;
            
        int flow = INT_MAX;
        int path = end;
        
        while( path != start ){
            
            flow = min( flow, capacity[parent[path]][path] );
            path = parent[path];
            
        }
        
        path = end;
        
        while( path != start ){
            
            capacity[path][parent[path]] += flow;
            capacity[parent[path]][path] -= flow;
            path = parent[path];
            
        }
        
        max_flow += flow;
    }
    
    return max_flow;
}


int main(){
    
    while( cin >> edge_num >> vertex_num ){
        
        memset( capacity, 0,     sizeof( capacity ) );
        memset( visit,    false, sizeof( visit ) );
        memset( parent,   0,     sizeof( parent ) );
        
        int start_pos = 1;
        int end_pos   = vertex_num;
        
        for( int i = 1; i <= edge_num; ++i ){
            
            int u, v, cap;
            cin >> u >> v >> cap;
            capacity[u][v] += cap;
            
        }
        
        int max_flow = Ford_Fulkerson( start_pos, end_pos );
        
        cout << max_flow << endl;
    }
    
    return 0;
}