Ford Fulkerson 算法

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

#define MAX_V 100
#define INF 1 << 30

struct Edge{

    int to;
    int cap;
    int rec;

    Edge( int to, int cap, int rec ){
        this->to  = to;
        this->cap = cap;
        this->rec = rec;
    }

};


vector< Edge > G[MAX_V];
bool visited[MAX_V];


void add_edge( int from, int to, int cap ){

    Edge e  = Edge( to, cap, G[to].size() );
    Edge re = Edge( from, cap, G[from].size() );

    G[from].push_back( e );
    G[to].push_back( re );

}


int find_flow( int from, int des, int flow ){

    if( from == des )
        return flow;

    visited[from] = true;

    for( int i = 0; i < G[from].size(); ++i ){

        Edge& e = G[from][i];

        if( !visited[e.to] && e.cap > 0 ){

            int f = find_flow( e.to, des, min( flow, e.cap ) );

            if( f > 0 ){

                e.cap -= f;
                G[e.to][e.rec].cap += f;

                return f;
            }
        }
    }

    return 0;
}


int max_flow( int src, int des ){

    int flow = 0;

    while( true ){

        memset( visited, false, sizeof( visited ) );

        int f = find_flow( src, des, INF );

        if( f == 0 )
            return flow;

        flow += f;
    }

    return flow;

}


int main(){

    add_edge( 1, 2, 3 );
    add_edge( 1, 3, 3 );
    add_edge( 2, 3, 2 );
    add_edge( 2, 4, 3 );
    add_edge( 3, 5, 2 );
    add_edge( 5, 6, 3 );
    add_edge( 4, 5, 4 );
    add_edge( 4, 6, 2 );

    int flow = max_flow( 1, 6 );

    cout << flow << endl;

    return 0;
}

class Edge( object ):

    def __init__( self, u, v, cap ):
        self.src = u
        self.des = v
        self.cap = cap
        

    def __repr__( self ):
        return "%s -> %s( %s )"%( self.src, self.des, self.cap )


class FlowNetwork( object ):

    def __init__( self ):
        self.graph = {}
        self.flow  = {}
        

    def find_flow( self, src, des, path ):
        if src == des:
            return path
        for e in self.get_edges( src ):
            residuals = e.cap - self.flow[e]
            if residuals > 0 and e not in path:
                res = self.find_flow( e.des, des, path + [e] )
                if res != None:
                    return res
                

    def max_flow( self, src, des ):
        while True:
            path = self.find_flow( src, des, [] )
            if path == None:
                return sum( self.flow[e] for e in self.get_edges( src ) )
            residuals = [e.cap - self.flow[e] for e in path]
            flow = min( residuals )
            for e in path:
                self.flow[e]    += flow
                self.flow[e.re] -= flow
                

    def add_vertex( self, v ):
        self.graph[v] = []
        

    def add_edge( self, u, v, cap ):
        if u == v:
            raise ValueError( "u == v" )
        e     = Edge( u, v, cap )
        re    = Edge( v, u, cap )
        e.re  = re
        re.re = e
        self.graph[u].append( e )
        self.graph[v].append( re )
        self.flow[e]  = 0
        self.flow[re] = 0


    def get_edges( self, v ):
        return self.graph[v]


if __name__ == "__main__":
    
    g = FlowNetwork()
    
    for v in range( 1, 7 ):
        g.add_vertex( v )
        
    g.add_edge( 1, 2, 3 )
    g.add_edge( 1, 3, 3 )
    g.add_edge( 2, 3, 2 )
    g.add_edge( 2, 4, 3 )
    g.add_edge( 3, 5, 2 )
    g.add_edge( 5, 6, 3 )
    g.add_edge( 4, 5, 4 )
    g.add_edge( 4, 6, 2 )
    
    print g.max_flow( 1, 6 )