while (bfs (source, sink)) // cat timp mai exista un drum de ameliorare
	{
		min = oo;

		for (i = sink; i; i = t[i])

		for (i = sink; i != source; i = t[i])

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

		for (i = sink ; i; i = t[i])

		for (i = sink ; i != source; i = t[i])

			flux[ t[i] ][i] += min, //adaugam minimul la fluxul de pe arcele de pe drum
			flux[i][ t[i] ] -= min; //scadem minimul de pe arcele inverse

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 dinic (int source, int sink)

{

	int flow=0; //fluxul
	int i, min,j;

	int flow = 0; //fluxul
	int i, min, j;

	while(bfs(source, sink)) // cat timp mai exista un drum de ameliorare

	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)

		for (j = source;j < sink;++j)
			if (cap[j][sink] - flux[j][sink] > 0)

			{

				min=oo;

				min = oo;

				if(cap[j][sink]-flux[j][sink] < min) min=cap[j][sink]-flux[j][sink];

				if (cap[j][sink] - flux[j][sink] < min)
                                       min = cap[j][sink] - flux[j][sink];

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

				for (i = j; i != source; i = t[i])
					if (cap[ t[i] ][i] - flux[ t[i] ][i] < min)
                                                min = cap[ t[i] ][i] - flux[ t[i] ][i];
 
                                //calculam minimul dintre capacitatile de pe drum

				if(min == oo) continue;

				if (min == oo)
                                      continue;

				flux[j][sink]+=min;
				flux[sink][j]-=min;

				flux[j][sink] += min;
				flux[sink][j] -= min;

				for(i=j ; i; i=t[i])
					flux[t[i]][i]+=min, //adaugam minimul la fluxul de pe arcele de pe drum
					flux[i][t[i]]-=min; //scadem minimul de pe arcele inverse

				for (i = j ; i != source; i=t[i])
					flux[ t[i] ][i] += min, //adaugam minimul la fluxul de pe arcele de pe drum
					flux[i][ t[i] ] -= min; //scadem minimul de pe arcele inverse

				flow+=min; // adaugam minimul la flux

				flow += min; // adaugam minimul la flux

			}
	}
     return flow;

== code(c) |

void support(int n)

inline void support(int n)

{
    vector<int>::iterator it;