Comprender el algoritmo de Ford-Foxson

    En este tutorial, aprenderá qué es el algoritmo Ford-Fulkerson. Además, también encontrará ejemplos en lenguaje C.
    El algoritmo Ford-Fulkerson es un método codicioso para calcular el tráfico máximo en una red o gráfico.
    El término red de flujo se usa para describir una red compuesta de vértices y bordes. La red usa nodos fuente (S) y nodos sumideros (T) para describir bordes. Cada vértice, excepto S y T, puede recibir y enviar la misma cantidad de contenido. S solo puede enviar, T solo puede recibir.
    Podemos usar el flujo de líquido en redes de tuberías de diferentes capacidades para visualizar nuestra comprensión del algoritmo. Cada tubería tiene un cierto volumen de líquido, que se puede transportar en una instancia. Para el algoritmo de Ford-Foxson, necesitamos averiguar cuánto líquido puede fluir desde el nodo fuente al nodo receptor de la red en una instancia.

Términos utilizados

Ruta aumentada
    Es la ruta disponible en la red de streaming.
El gráfico residual
    representa una red de flujos con otros posibles flujos.
La capacidad restante es
    la capacidad marginal después de restar el caudal de la capacidad máxima.

¿Cómo funciona el algoritmo Ford-Fulkerson?

    El algoritmo es como sigue:

1. Inicialice el flujo en todos los bordes a 0.
2. Cuando hay una ruta de aumento entre el nodo de origen y el nodo receptor, esta ruta se agrega al flujo.
3. Actualice la gráfica residual.

    Si es necesario, también podemos considerar caminos inversos, porque si no se consideran, es posible que nunca encontremos el flujo máximo.
    Los conceptos anteriores se pueden entender mediante los siguientes ejemplos.

Ejemplo de Ford-Fulkerson

    El flujo de todos los lados es 0 al principio.

1. Elija cualquier camino de S a T. En este paso, elegimos el camino SABT.
   La capacidad más pequeña entre los tres lados es 2 (BT). Con base en esto, actualice el flujo / capacidad de cada ruta.
   
2. Elija otra ruta SDCT. La capacidad mínima de estos bordes es 3 (SD).
   
   Actualice la capacidad en función de esto.
   
3. Ahora, consideremos el camino inverso BD. Seleccione la ruta SABDCT. La capacidad mínima restante entre los bordes es 1 (CC). (Debido a que la capacidad de CC es 4 y ya hay un flujo de 3, agregue 1 más como máximo, y toda la ruta solo puede transportar 1 flujo)
   
   Actualice la capacidad.
   
   La capacidad de las rutas de avance y retroceso se considera por separado.
4. Sume todo el tráfico = 2 + 3 + 1 = 6, que es el tráfico máximo posible en la red de tráfico.
   Desde el nodo fuente S hasta el nodo receptor T, hay tres rutas para el tráfico:
   SABT, el tráfico máximo es 2;
   SDCT, el tráfico máximo es 3;
   SABDCT, el tráfico máximo es 1.
   Entonces el flujo máximo es 6.
   Tenga en cuenta que si la capacidad en cualquier lado está llena, la ruta no se puede utilizar para transportar más tráfico.

C ejemplo

/ Ford - Fulkerson algorith in C

#include <stdio.h>

#define A 0
#define B 1
#define C 2
#define MAX_NODES 1000
#define O 1000000000

int n;
int e;
int capacity[MAX_NODES][MAX_NODES];
int flow[MAX_NODES][MAX_NODES];
int color[MAX_NODES];
int pred[MAX_NODES];

int min(int x, int y) {
    
    
  return x < y ? x : y;
}

int head, tail;
int q[MAX_NODES + 2];

void enqueue(int x) {
    
    
  q[tail] = x;
  tail++;
  color[x] = B;
}

int dequeue() {
    
    
  int x = q[head];
  head++;
  color[x] = C;
  return x;
}

// Using BFS as a searching algorithm
int bfs(int start, int target) {
    
    
  int u, v;
  for (u = 0; u < n; u++) {
    
    
    color[u] = A;
  }
  head = tail = 0;
  enqueue(start);
  pred[start] = -1;
  while (head != tail) {
    
    
    u = dequeue();
    for (v = 0; v < n; v++) {
    
    
      if (color[v] == A && capacity[u][v] - flow[u][v] > 0) {
    
    
        enqueue(v);
        pred[v] = u;
      }
    }
  }
  return color[target] == C;
}

// Applying fordfulkerson algorithm
int fordFulkerson(int source, int sink) {
    
    
  int i, j, u;
  int max_flow = 0;
  for (i = 0; i < n; i++) {
    
    
    for (j = 0; j < n; j++) {
    
    
      flow[i][j] = 0;
    }
  }

  // Updating the residual values of edges
  while (bfs(source, sink)) {
    
    
    int increment = O;
    for (u = n - 1; pred[u] >= 0; u = pred[u]) {
    
    
      increment = min(increment, capacity[pred[u]][u] - flow[pred[u]][u]);
    }
    for (u = n - 1; pred[u] >= 0; u = pred[u]) {
    
    
      flow[pred[u]][u] += increment;
      flow[u][pred[u]] -= increment;
    }
    // Adding the path flows
    max_flow += increment;
  }
  return max_flow;
}

int main() {
    
    
  for (int i = 0; i < n; i++) {
    
    
    for (int j = 0; j < n; j++) {
    
    
      capacity[i][j] = 0;
    }
  }
  n = 6;
  e = 7;

  capacity[0][1] = 8;
  capacity[0][4] = 3;
  capacity[1][2] = 9;
  capacity[2][4] = 7;
  capacity[2][5] = 2;
  capacity[3][5] = 5;
  capacity[4][2] = 7;
  capacity[4][3] = 4;

  int s = 0, t = 5;
  printf("Max Flow: %d\n", fordFulkerson(s, t));
}

Aplicación Ford-Fulkerson

• Red de abastecimiento de agua
• Problema de coincidencia de gráficos bipartitos
• Circulación bajo demanda

Documentos de referencia

[1] Parewa Labs Pvt. Ltd. Algoritmo Ford-Fulkerson [EB / OL] .https: //www.programiz.com/dsa/ford-fulkerson-algorithm,2020-01-01.