#define N 128
#define oo 0x3f3f3f3f //infinit
int cap[N][N], flux[N][N];

int t[N];//t= vector de tati

int t[N];

int n, m;
int bfs(int source, int sink)

	{
		int u=Q[p++];//scoatem primul element din coada

		for(int i=1;i<=n;++i) // pt fiecare nod ( adiacent )

		for(int i=source;i<=sink;++i) // pt fiecare nod ( adiacent )

			if(!use[i]) // nu am folosit nodul
				if(cap[u][i] - flux[u][i] > 0) // mai putem pompa?
				{

	{
		min=oo;
		for(i=sink; i; i=t[i])

			if(cap[i] > min) min=cap[i]; //calculam minimul dintre capacitatile de pe drum

			if(cap[t[i]][i] < min) min=cap[t[i]][i]; //calculam minimul dintre capacitatile de pe drum

		for(i=sink ; i; i=t[i])
			f[t[i]][i]+=min, //adaugam minimul la fluxul de pe arcele de pe drum

		flow+=min; // adaugam minimul la flux
	}

      return flow;

}
==

h2. 2. Algoritmul lui Dinic si algoritmul lui Karzanov

h3 Algoritmul lui Dinic

h3. Algoritmul lui Dinic
 
In cadrul fiecarui ciclu while al algoritmului Edmond-Karp determinam un singur drum de ameliorare. In cadrul algoritmului lui Dinic se determina nu un singur drum, ci un numar maximal (nu neaparat maxim) de drumuri de ameliorare. Practic ne uitam la nodurile adiacente destinatiei si daca se poate ajunge in destinatie din acel nod atunci saturam drumul respectiv.
 
== code(c) |
int dinic(int source, int sink)
{
	int flow=0; //fluxul
	int i, min,j;
 
	while(bfs(source, sink)) // cat timp mai exista un drum de ameliorare
	{
 
		for(j=source;j<sink;++j)
			if(cap[j][sink]-flux[j][sink] > 0)
			{
 
				min=oo;
 
				if(cap[j][sink] < min) min=cap[j][sink];
 
				for(i=j; i; i=t[i])
					if(cap[t[i]][i] < min) min=cap[t[i]][i]; //calculam minimul dintre capacitatile de pe drum
 
				if(min == oo) continue;
 
				f[j][sink]+=min;
				f[sink][j]-=min;
 
				for(i=j ; i; i=t[i])
					f[t[i]][i]+=min, //adaugam minimul la fluxul de pe arcele de pe drum
					f[i][t[i]]-=min; //scadem minimul de pe arcele inverse
 
				flow+=min; // adaugam minimul la flux
			}
	}
     return flow;
}
==