MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

AL REPUBLICII MOLDOVA
UNIVERSITATEA TEHNICĂ A MOLDOVEI

INFORMATICĂ ȘI INGINERIA SISTEMELOR

RAPORT
Lucrarea de laborator nr. 6
Tema: Determinarea fluxului maxim într-o reţea de transport.

A efectuat: Batranac Adriana

st. gr. AI-221

A verificat: V.Melnic

Chişinău, 2023
Lucrare de laborator Nr. 6
Tema: Determinarea fluxului maxim într-o reţea de transport.
1. Scopul lucrării:
1. Studierea noţiunilor de bază legate de reţelele de transport;
2. Programarea algoritmului Ford-Fulkerson pentru determinarea fluxului maxim într-o reţea de
transport .
2. Sarcina:
1. Realizaţi procedura introducerii unei reţele de transport cu posibilităţi de verificare a
corectitudinii datelor introduse.
2. În conformitate cu algoritmul Ford-Fulkerson elaboraţi procedura determinării fluxului maxim
pentru valori întregi ale capacităţilor arcelor.
3. Realizaţi un program cu următoarele funcţii:
➢ Introducerea reţelei de transport în memorie,
➢ Determinarea fluxului maxim pentru reţeaua concretă; ➢ Extragerea informaţiei la display.
3. Întrebări de control:
1. Ce se numeşte reţea de transport?
2. Formulaţi noţiunile de flux şi capacitate.
3. Ce este un arc saturat? Dar un drum saturat?
4. Ce se numeşte flux complet? Ce este un flux maxim?
5. Definiţi noţiunea de tăietură.
6. Formulaţi teorema Ford-Fulkerson.
7. Descrieţi algoritmul de determinare a fluxului maxim.

#include<sdio.h>
#include <stdbool.h>
#include <limits.h>

#define N 100

int c[N][N];
int f[N][N];
int pa[N];
bool vis[N];

int min(int a, int b)

{
return (a < b) ? a : b;
}

// pentru a determina atingerea nodul final

bool bfs(int source, int final, int n)
{
 int queue[N];
int front=0,
rear=0;

for (int i=0; i < n; i++)

{
pa[i]=-1; // calea spre detinat. Initial e -1 ce presupune non existenta
vis[i]=false; // daca nodu era visitad
}

vis[source]=true;
queue[rear++]=source;

while (front < rear)

{
int u=queue[front++];

for (int v=0; v<n; v++)

{
if ( !vis[v] && c[u][v] - f[u][v] > 0) //daca nu visitat si are connectiunea
{
vis[v]=true; //visitat
pa[v]=u; // punem in array
queue[rear++]=v; // punem in fata

if (v==final) //daca exista

{
return true;
}
}
}
}

return false;
}

int ford_fulkerson(int s, int fin, int n)

{
int mf=0;
 while (bfs(s, fin, n)) //pan cand calea exista
{
int path_flow=INT_MAX; //fluxului

for (int v=fin; v !=s; v=pa[v]) // de la final pana la source

{
int u=pa[v];
path_flow=min(path_flow, c[u][v] - f[u][v]); //calcularea diff. dintre
posibil fluxul (c) si current fluxl (f). apoi folosteste in
}

for (int v=fin; v !=s; v=pa[v])

{
int u=pa[v];
f[u][v]+=path_flow; //flux min de la u-v
f[v][u] -=path_flow; //pentru considerarea fluxul care o sa parcurge in
directia contra
}

mf+=path_flow; // dupa fie care iteratia flux maxim este modificat cu fie
care calea
}

mf--;
return mf;
}

void read_network(int n)
{
int u,v,w,num_edges;
printf("Introduceti numarul de muchii: ");

scanf("%d", &num_edges);
printf("Introduceti nodul de start, nodul final si ponderea muchiei pentru
fiecare arc:\n");

for (int i=0; i < num_edges; i++)

{
scanf("%d %d %d", &u, &v, &w);
c[u][v]=w;
 }
}

int main() {
int n, s,fin;

printf("Introduceti numarul de noduri: ");

scanf("%d", &n);

printf("Introduceti nodul de start si nodul final: ");

scanf("%d %d", &s, &fin);

read_network(n);

printf("Fluxul maxim intre nodurile %d si %d este: %d\n", s, fin,

ford_fulkerson(s, fin, n));
return 0;
}