#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 )