Flux si Cuplaj

(Categoria Algoritmi, autor Mircea Dima)

1. Retele de transport
2. Algoritmiii Ford Fulkerson si Edmonds-Karp
   • UVA 10735
   • PKU 2391
3. Algoritmul lui Dinic si algoritmul lui Karzanov
   • Tero
4. Taietura minima in graf / conexiune de muchii
   • Hardware Store
   • SPOJ Optmark
   • ZJU 2429
5. Flux cu capacitati inferioare si superioare
   • SGU 176
   • Drumuri2
   • Joc (finala .campion 2006)
6. Cuplaj in graf bipartit
   • SGU 234, 190
7. Algoritm de flux maxim pentru cuplaj
   • CEOI 2002 Guards
   • PKU 2226
8. Cuplaj folosind lanturi alternante (cunoscut si ca PairUp)
   • Dicing/KOS polonezi
   • PKU 3189
9. Algoritmul Hopcroft-Karp
   • Java
   • Baltica 2001 Knights
10. Suport in graf bipartit
    • Felinare
    • SGU 234
    • Knights - BalticOI 2001
11. Cuplaj maxim de cost minim (cu Bellman-Ford cu si fara coada)
    • Traseu
    • Trafic
    • SGU 252
    • UVA 10806
    • Problema chinezi
12. Cuplaj maxim de cost minim folosind Dijkstra
    • CC

1. Retele de transport

O retea de transport G=(V, E) este un graf orientat in care fiecarui arc (u, v) ∈ E ii este asociata o capacitate nenegativa c(u,v) >=0.
Vom distinge 2 varfuri importante in retea: varful sursa S si varful destinatie D.
Un flux in reteaua de mai sus este o functie f: V x V -> R care satisface urmatoarele conditii:

1. Restrictie de capacitate: pentru orice u, v ∈ V avem f(u, v)<=c(u, v)
2. Antisimetrie: pentru orice u, v ∈ V avem f(u, v)=-f(v, u)
3. Conservarea fluxului: pentru orice u ∈ V - {S, D} avem ∑ v ∈ V din f(u, v) = 0

Prima restrictie impune pur si simplu ca fluxul de la un varf la altul sa nu depaseasca valoarea capacitatii.
Antisimetria impune ca fluxul de la un varf u la un varf v sa fie egal cu opusul fluxului de la varful v la u. Astfel, fluxul de la un varf la el insusi este 0.
Conservarea fluxului impune ca "ceea ce intra intr-un nod sa fie egal cu ceea ce iese din nod"

Mai pe intelesul tuturor putem sa ne imaginam ca fiecare arc este o conducta pentru material. Fiecare conducta are o capacitate data, care este defapt ritmul maxim cu care lichidul se poate deplasa in conducta. De exemplu, printr-o teava pot curge cel mult 2000 litri de apa pe ora, sau pe un fir conductor un curent electric de maximum 20 amperi. Varfurile sunt jonctiunile conductelor si in afara varfului sursa si destinatie, materialul nu se poate acumula in nici un varf. Aceasta proprietate se numeste conservarea fluxului si este identica cu legea lui Kirchoff in cazul curentului electric.

2. Algoritmiii Ford Fulkerson si Edmonds-Karp

Ford-Fulkerson(c, f)
      f[i][j]=0 pt i,j=1,n
      cat timp exista un drum de ameliorare p executa
          mareste fluxul f de-a lungul drumului p
      returneaza f

Ce este un drum de ameliorare? Un drum de ameliorare este un drum de la sursa la destinatie care are proprietatea ca fiecare muchie are cap[i]-flux[i] > 0,
sau mai bine zis, "se mai poate pompa lichid prin conductele ce compun drumul".

Conform acestei metode se poate implementa un algoritm cu o complexitate ce depinde de capacitati (marim fluxul cu o unitate la fiecare pas).

Edmonds si Karp au dat urmatorul algoritm ce are complexitate O(N *M^2):
Drumul de ameliorare il vom determina folosind un BFS (cautare in latime) si in loc sa marim fluxul cu o singura unitate, vom mari fluxul cu valoarea minima dintre capacitatile de pe drumul de amelioarare. Se observa intuitiv ca dupa saturarea unui drum de ameliorare se satureaza cel putin o muchie. Dupa O(M) saturari de drumuri se observa ca cel mai scurt drum de la sursa la destinatie trebuie sa creasca. Asadar dupa O(N*M) astfel de operatii destinatia nu va mai fi accesibila din sursa si prin urmare avem fluxul maxim. Cum fiecare operatie (din cele O(N*M) ) au complexitate O(M+N) (BFS) rezulta complexitatea finala O(N* M^2).

#include <cstdio>
#define N 128
#define oo 0x3f3f3f3f //infinit
int cap[N][N], flux[N][N];
int t[N];//t= vector de tati
int n, m;

int bfs(int source, int sink)
{
	int Q[N+1], p=0,q=0;
	bool use[N];
	memset(use, 0, sizeof(use));
	memset(t, 0, sizeof(t));
	Q[0]=source;
	use[source]=1;
	
	while(p<=q) 
	{
		int u=Q[p++];//scoatem primul element din coada
		
		for(int i=1;i<=n;++i) // pt fiecare nod ( adiacent )
			if(!use[i]) // nu am folosit nodul
				if(cap[u][i] - flux[u][i] > 0) // mai putem pompa?
				{
					Q[++q]=i; // inseram nodul i in coada
					t[i]=u;  
					use[i]=1; 
				}
	}
				
	if(t[sink]) return 1;
	return 0;
}

int edmond-karp(int source, int sink)
{
	int flow=0; //fluxul
	int i, min;
	
	while(bfs(source, sink)) // cat timp mai exista un drum de ameliorare
	{
		min=oo;
		for(i=sink; i; i=t[i])
			if(cap[i] > min) min=cap[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
			f[i][t[i]]-=min; //scadem minimul de pe arcele inverse
		
		flow+=min; // adaugam minimul la flux
	}
	
}

2. Algoritmul lui Dinic si algoritmul lui Karzanov

h3 Algoritmul lui Dinic