Giriş

Öğrenme Çıktıları

Akış Ağları

Maksimum Akış (Maximum Flow) Problemi

Akış Ağları

Akış (Flow) ve Kısıtları

Akış Ağları

Birden Çok Kaynak ve Hedef

• Birden çok kaynak (s₁ … sₙ) ve hedef (t₁ … tₘ) varsa yeni bir süper kaynak S ve süper hedef T eklenir.
• S → sᵢ ve tⱼ → T kenarlarına sınırsız (∞) kapasite verilir; problem tek kaynaklı, tek hedefli maksimum akışa dönüşür.

Artık Ağ ve Artış Yolu

Artık Ağ (Residual Network)

• Artık ağ G_f, mevcut akış f altında hâlâ gönderilebilecek akışı gösterir.
• İleri kenar: c_f(u, v) = c(u, v) − f(u, v) — kapasiteden akış çıkarılır; akış kapasiteden azsa kalan kapasite pozitiftir.
• Ters kenar: c_f(v, u) = f(u, v) — gönderilmiş akış geri alınabilir (iptal edilebilir).
• Yalnızca c_f > 0 olan kenarlar G_f'ye girer; artış yolları bu ağda aranır.

Düz ok: ileri (kalan) kapasite · kesikli ok: ters kenar. Ters kenarlar olmadan algoritma ilk yanlış seçimini düzeltemez.

Artık Ağ ve Artış Yolu

Artış Yolu (Augmenting Path)

Kesimler

Kesimler (Cuts)

Kesimler

Maksimum Akış – Minimum Kesim Teoremi

16 kesimin en küçüğü 7'dir; bulunan akışın değeri de 7 olduğu için bu akış maksimumdur.

Kesimler

Ağ Akış Algoritmaları (Network Flow)

Amaç: kısıtlar altında kaynaktan hedefe mümkün olan en fazla akışı sağlamak.

|f*|: maksimum akışın değeri. Ford-Fulkerson'ın süresi tam sayı kapasiteler için geçerlidir.

Ford-Fulkerson

Ford-Fulkerson Yöntemi

• L. R. Ford Jr. ve D. R. Fulkerson tarafından geliştirilmiştir (1956).
• Ağırlıklı (kapasiteli) yönlü çizgede iki düğüm arasındaki maksimum akışı bulur: kaynaktan hedefe, belirli kapasiteli borularla gönderilebilecek en fazla suyu modelleyen bir çizge problemi.
• İlkeler: ağ yönlü bir çizgedir; her kenarın bir kapasitesi vardır; başlangıçta tüm akışlar 0'dır; artış yolu bulma adımı tekrarlanarak maksimum akışa ulaşılır.
• Artış yolunun nasıl bulunacağını belirtmediği için bir yöntemdir: Ford-Fulkerson genellikle DFS, Edmonds-Karp ise BFS kullanır.

Ford-Fulkerson

Ford-Fulkerson: Algoritma Adımları

Ford-Fulkerson

Ford-Fulkerson Örneği 1

Ford-Fulkerson

Ford-Fulkerson Örneği 2: Ters Kenar Kullanımı

Ford-Fulkerson

Ters Kenarlar Neden Gerekli?

Ford-Fulkerson

Ford-Fulkerson: Sözde Kod

FORD_FULKERSON(G, kaynak, hedef):
  akış[u, v] = 0, her bir (u, v) için E içinde     // başlangıçta 0
  maksimumAkış = 0
  döngü artırıcı yol var iken:
    yol = DFS(G, kaynak, hedef, akış)            // c − akış > 0 kenarlarla
    delta = ∞                                    // yoldaki en küçük kalan kapasite
    v = hedef
    döngü v ≠ kaynak iken:
      u = yol.ata[v]
      delta = min(delta, kapasite[u, v] − akış[u, v])
      v = u
    v = hedef                                    // yoldaki akışları güncelle
    döngü v ≠ kaynak iken:
      u = yol.ata[v]
      akış[u, v] += delta
      akış[v, u] −= delta                        // ters kenar
      v = u
    maksimumAkış += delta
  döndür maksimumAkış, akış

Ford-Fulkerson

Java: DFS ile Artış Yolu

boolean dfs(int u, int hedef,
            boolean[] ziyaret, int[] ata) {
  ziyaret[u] = true;
  if (u == hedef) return true;
  for (int v = 0; v < V; v++) {
    if (!ziyaret[v] && artik[u][v] > 0) {
      ata[v] = u;
      if (dfs(v, hedef, ziyaret, ata))
        return true;
    }
  }
  return false;   // bu daldan hedefe yol yok
}

Ford-Fulkerson

Ford-Fulkerson: Karmaşıklık Analizi

• Çalışma süresi ağın yapısına ve kapasitelere bağlıdır.
• Bir artış yolu bulmak (DFS/BFS) ve akışı güncellemek: O(E).
• Kapasiteler tam sayı ise her artış yolu akışı en az 1 birim artırır → en fazla |f*| tekrar.
• Toplam: O(E · |f*|); E kenar sayısı, |f*| maksimum akış değeri.

Ford-Fulkerson

Kötü Yol Seçimi: 2000 Artış

Edmonds-Karp

Edmonds-Karp Algoritması

• Ağırlıklı yönlü çizgede iki düğüm arasındaki maksimum akışı bulur; Ford-Fulkerson yönteminin bir türevidir.
• Jack Edmonds ve Richard Karp tarafından geliştirilmiştir (1972; Dinic 1970'te bağımsız olarak).
• Artış yollarını BFS (genişlik öncelikli arama) ile bulur: her seferinde kenar sayısı en az olan artış yolu seçilir.
• Edmonds-Karp BFS'yi artış yolu bulmak için kullanır; Dinic ise BFS'yi daha fazla akış mümkün mü diye bakmak ve seviye çizgesi kurmak için kullanır.

Edmonds-Karp

Edmonds-Karp: Karmaşıklık O(V · E²)

• Her tur bir BFS ve bir yol güncellemesidir: O(E).
• BFS en kısa yolu seçtiği için s'ten her düğüme olan artık ağ uzaklığı hiç azalmaz.
• Her artışta en az bir kenar kritik olur (doyar). Aynı kenarın yeniden kritik olabilmesi için uzaklığı en az 2 artmalıdır; uzaklık ≤ V olduğundan her kenar en fazla ~V/2 kez kritik olur.
• Artış sayısı O(V · E) → toplam O(V · E) · O(E) = O(V · E²); E kenar, V düğüm sayısı.

Edmonds-Karp

Java: BFS ile Artış Yolu

boolean bfs(int kaynak, int hedef, int[] ata) {
  boolean[] ziyaret = new boolean[V];
  Queue<Integer> kuyruk = new LinkedList<>();
  kuyruk.add(kaynak);
  ziyaret[kaynak] = true;
  ata[kaynak] = -1;
  while (!kuyruk.isEmpty()) {
    int u = kuyruk.poll();
    for (int v = 0; v < V; v++)
      if (!ziyaret[v] && artik[u][v] > 0) {
        kuyruk.add(v);
        ata[v] = u;
        ziyaret[v] = true;
      }
  }
  return ziyaret[hedef];
}

Edmonds-Karp · Kodu adım adım çalıştır

edmondsKarp(s, t): Kodu Adım Adım İzle

int edmondsKarp(int s, int t) {
  int maksAkis = 0;
  int[] ata = new int[V];
  while (bfs(s, t, ata)) {
    int akis = Integer.MAX_VALUE;
    for (int v = t; v != s; v = ata[v])
      akis = Math.min(akis, artik[ata[v]][v]);
    for (int v = t; v != s; v = ata[v]) {
      int u = ata[v];
      artik[u][v] -= akis;  // ileri
      artik[v][u] += akis;  // ters
    }
    maksAkis += akis;
  }
  return maksAkis;
}

Edmonds-Karp

Edmonds-Karp Örneği

Edmonds-Karp

Edmonds-Karp Örneği 2

Edmonds-Karp

Edmonds-Karp Örneği 3: Artık Ağ Üzerinde

Dinic

Dinic Algoritması

• Bir çizgede maksimum akışı bulur (Y. Dinitz, 1970); kapasiteli (ağırlıklı) çizge üzerinde çalışır.
• Seviye çizgesi (level graph): artık ağda BFS ile her düğümün seviyesi (kaynağa uzaklığı) bulunur; yalnızca seviye(v) = seviye(u) + 1 olan kenarlar tutulur.
• Engelleyici akış (blocking flow): seviye çizgesinde her s–t yolunda en az bir doymuş kenar bırakan akış; DFS ile bulunur.
• Akış ters kenarlarla güncellenir; hedef seviye çizgesinde ulaşılamaz olana kadar fazlar tekrarlanır.

Dinic

Dinic: Algoritma Adımları

Dinic

Dinic Örneği: Fazlar

Dinic

Dinic: Sözde Kod

DINIC(G, kaynak, hedef):
  akış = [ ]       // her kenar için 0
  maksimumAkış = 0
  döngü BFS(G, kaynak, hedef, akış) iken:
    // seviye çizgesi kuruldu
    döngü engelleyici akış var iken:
      delta = DFS(G, kaynak, hedef,
                  akış, seviye, ∞)
      maksimumAkış += delta
  döndür maksimumAkış

BFS(G, kaynak, hedef, akış):
  seviye[v] = −1, her v için
  seviye[kaynak] = 0
  kuyruk.ekle(kaynak)
  döngü kuyruk boş değil iken:
    u = kuyruk.çıkar()
    her bir (u, v) için G[u] içinde:
      eğer seviye[v] < 0 ve
           kapasite[u,v] − akış[u,v] > 0:
        seviye[v] = seviye[u] + 1
        kuyruk.ekle(v)
  döndür seviye[hedef] ≥ 0

DFS(G, u, hedef, akış, seviye, lim):
  eğer u == hedef: döndür lim
  her bir (u, v) için G[u] içinde:
    kalan = kapasite[u,v] − akış[u,v]
    eğer seviye[v] == seviye[u] + 1
         ve kalan > 0:
      delta = DFS(G, v, hedef, akış,
                  seviye, min(lim, kalan))
      eğer delta > 0:
        akış[u, v] += delta
        akış[v, u] −= delta   // ters
        döndür delta
  döndür 0

Dinic

Java: Seviyeli DFS ve Kaldığı Yer Dizisi

int dfs(int u, int t, int akis, int[] basla) {
  if (u == t) return akis;
  for (; basla[u] < komsu[u].size(); basla[u]++) {
    Kenar k = komsu[u].get(basla[u]);
    if (seviye[k.hedef] == seviye[u] + 1 && k.akis < k.kapasite) {
      int d = dfs(k.hedef, t, Math.min(akis, k.kapasite - k.akis), basla);
      if (d > 0) {
        k.akis += d;                                 // ileri kenar
        komsu[k.hedef].get(k.tersIndis).akis -= d;   // ters kenar
        return d;
      }
    }
  }
  return 0;   // u'dan t'ye seviyeli yol kalmadı
}

• Kenarlar komşu listesinde tutulur; her kenar ters kenarının indisini (tersIndis) bilir.
• basla[u]: u'da denenecek sıradaki kenar (current arc). Çıkmaz kenar bir daha denenmez; bir fazdaki tüm DFS'ler toplam O(V · E).
• Her fazın başında basla sıfırlanır, seviyeler BFS ile yeniden hesaplanır.

Dinic

Dinic: Karmaşıklık O(V² · E)

• Her faz bir BFS gerektirir: O(V + E).
• Her fazdan sonra s–t uzaklığı kesin olarak artar ve uzaklık ≤ V − 1 olduğundan en kötü durumda V faz olabilir.
• Bir fazdaki engelleyici akış: her artış yolu O(V) uzunluktadır ve en fazla E yol bulunur; kaldığı yer dizisiyle faz başına O(V · E).
• Toplam: O(V) · O(V · E) = O(V² · E).

İtme–Yeniden Etiketleme

İtme ve Yeniden Etiketleme (Push–Relabel)

• A. Goldberg ve R. Tarjan (1988). Artış yolu aramaz; düğümler üzerinde yerel işlemlerle çalışır.
• Kaynaktan çıkan tüm kenarları doldurarak aşırı akış başlatır; akış, korunum kısıtını geçici olarak bozan bir ön akıştır (preflow).
• Her düğümün bir yükseklik (height) etiketi vardır; akış yalnızca yüksekten bir alçağa doğru itilir (push), su gibi.
• Bir düğüm fazlasını itemiyorsa yüksekliği artırılır (relabel).
• Aşırı akışı olan düğüm kalmayınca ön akış gerçek bir akıştır; hedefteki aşırı akış maksimum akışı verir.

İtme–Yeniden Etiketleme

Ön Akış ve Aşırı Akış (Excess Flow)

İtme–Yeniden Etiketleme

Yükseklik Fonksiyonu ve Başlangıç

İtme–Yeniden Etiketleme

İtme (Push) ve Yeniden Etiketleme (Relabel)

İtme–Yeniden Etiketleme

İtme–Yeniden Etiketleme Örneği

İtme–Yeniden Etiketleme

İtme–Yeniden Etiketleme: Sözde Kod

PUSH_RELABEL(G, kaynak, hedef):
  yükseklik[kaynak] = |V|
  yükseklik[v] = 0, v ≠ kaynak
  aşırı[v] = 0, her v için
  akış[e] = 0, her kenar e için
  // ön akış: kaynak kenarlarını doldur
  her bir (kaynak, v) ∈ E için:
    c = kapasite[kaynak, v]
    akış[kaynak, v] = c
    akış[v, kaynak] = −c
    aşırı[v] = c
    aşırı[kaynak] −= c

döngü aşırı[u] > 0 olan u varken:
  // u ≠ kaynak, u ≠ hedef
  eğer kalan(u,v) > 0 ve
       yükseklik[u] == yükseklik[v]+1:
    // İtme
    delta = min(aşırı[u], kalan(u,v))
    akış[u,v] += delta
    akış[v,u] −= delta
    aşırı[u] −= delta
    aşırı[v] += delta
  değilse:
    // Yeniden etiketleme
    m = ∞
    her bir (u, v) için G[u] içinde:
      eğer akış[u,v] < kapasite[u,v]:
        m = min(m, yükseklik[v])
    yükseklik[u] = m + 1
döndür aşırı[hedef]
// kalan = kapasite − akış

İtme–Yeniden Etiketleme

Java: push ve relabel

boolean it(Dugum d) {
  for (Kenar k : d.kenarlar) {
    if (d.yukseklik > k.hedef.yukseklik
        && k.akis != k.kapasite) {
      int akis = Math.min(
        k.kapasite - k.akis, d.asiri);
      d.asiri -= akis;
      k.hedef.asiri += akis;
      k.akis += akis;
      tersKenariGuncelle(k, akis);
      return true;   // itme yapıldı
    }
  }
  return false;
}

void etiketle(Dugum d) {
  int minY = Integer.MAX_VALUE;
  for (Kenar k : d.kenarlar) {
    // yalnızca artık ağdaki kenarlar
    if (k.akis != k.kapasite
        && k.hedef.yukseklik < minY) {
      minY = k.hedef.yukseklik;
      d.yukseklik = minY + 1;
    }
  }
}

Ana döngü: aktif düğüm varken if (!it(d)) etiketle(d); — sonuç hedefin aşırı akışıdır. Ters kenarlar negatif akışla tutulur (kapasite 0).

İtme–Yeniden Etiketleme

İtme–Yeniden Etiketleme: Karmaşıklık

• Genel algoritma en kötü durumda O(V² · E); bir relabel en fazla derece kadar kenarı tarar (toplam O(V · E)).
• FIFO seçimiyle O(V³), en yüksek etiket seçimiyle O(V² · √E).
• Pratikte gap ve global relabeling sezgileriyle en hızlı genel amaçlı maksimum akış yöntemlerindendir.

Karşılaştırma ve Uygulamalar

Algoritmaların Karşılaştırması

Karşılaştırma ve Uygulamalar

Uygulamalar

Özet

Özet

Özet

Etkileşimli Simülatörler

Özet

Sık Yapılan Hatalar

Özet

Örnek Problemler

Özet

Alıştırmalar

1. Bir kenarın kapasitesi 1 artırılırsa maksimum akış en fazla ne kadar artar?
2. Tüm kapasiteler k ile çarpılırsa maksimum akış ve minimum kesim nasıl değişir?
3. Düğüm kapasiteleri c(v) varsa problem nasıl modellenir?
4. Son artık ağdan minimum kesimi bulan bir Java metodu yazın.
5. "Kötü durum" ağında DFS'li Ford-Fulkerson ve Edmonds-Karp en fazla kaç artış yapar?
6. s'ten t'ye kenar ayrık yol sayısı maksimum akışla nasıl bulunur?

Özet

Kaynaklar

• Cormen, Leiserson, Rivest ve Stein, Introduction to Algorithms, 4. baskı, MIT Press, 2022 (Bölüm 24: Maximum Flow).
• Kleinberg ve Tardos, Algorithm Design, Pearson, 2006 (Bölüm 7: Network Flow).
• Sedgewick ve Wayne, Algorithms, 4. baskı, 2011 (Bölüm 6.4: Maximum Flow).
• L. R. Ford ve D. R. Fulkerson, "Maximal Flow Through a Network", Canadian Journal of Mathematics 8, 1956.
• J. Edmonds ve R. M. Karp, "Theoretical Improvements in Algorithmic Efficiency for Network Flow Problems", Journal of the ACM 19(2), 1972.
• E. A. Dinic, "Algorithm for Solution of a Problem of Maximum Flow in Networks with Power Estimation", Soviet Math. Doklady 11, 1970.
• A. V. Goldberg ve R. E. Tarjan, "A New Approach to the Maximum-Flow Problem", Journal of the ACM 35(4), 1988.