Bölüm 4.2: En Kısa Yol Algoritmaları

Algoritmalar

GevşetmeDijkstraBellman-FordNegatif döngü Floyd-WarshallA* aramaBFS ile ağırlıksız yolKarşılaştırma

Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Kavramlar

Tek kaynaklı, tüm çiftler ve tek çift en kısa yol problemlerini ayırt etmek; gevşetme (relaxation) işlemini ve önceki (π) dizisini açıklamak.

Dijkstra ve Bellman-Ford

İki algoritmayı bir örnek çizge üzerinde adım adım çalıştırmak, uzaklık ve π tablolarını doldurmak, Java kodunu izlemek.

Negatif kenar ve döngü

Dijkstra'nın negatif kenarda neden yanıldığını göstermek; Bellman-Ford ve Floyd-Warshall ile negatif döngüyü tespit etmek.

Floyd-Warshall ve A*

Tüm çiftler için D ve Π matrislerini k = 1…n güncellemek; A*'ın f = g + h ile hedefe yönelen aramasını uygulamak ve algoritmaları karşılaştırmak.

Giriş

Yol Ağı Bir Çizgedir

Kavşaklar düğüm (vertex), yollar kenar (edge), yol uzunlukları ya da süreleri ağırlık (weight) olur.
Bir yolun uzunluğu = üzerindeki kenar ağırlıklarının toplamı.
En kısa yol (shortest path): iki düğüm arasındaki toplam ağırlığı en küçük yol; uzunluğu δ(s, v) ile gösterilir.
Örnek: Ev → Okul için Ev–1–2–4–Okul = 4 + 2 + 3 + 3 = 12; daha az kenarlı Ev–1–4–Okul ise 13 eder.

Kenar sayısı en az olan yol, ağırlıklı çizgede en kısa yol olmayabilir. Navigasyon, ağ yönlendirme (OSPF, RIP), oyunlarda yol bulma ve lojistik bu problemi çözer.

Giriş

En Kısa Yol Problem Türleri

Tek kaynaklı(single-source) s'den tüm düğümlere. Dijkstra, Bellman-Ford, BFS.

Tüm çiftler(all-pairs) her (u, v) çifti; sonuç n × n matris. Floyd-Warshall.

Tek çift(single-pair) yalnızca s → t; hedefe yönelen arama. A*.

Algoritma	Ne bulur?	Kısıt / not
Dijkstra	kaynaktan tüm düğümlere	kenar ağırlıkları negatif olmamalı
Bellman-Ford	kaynaktan tüm düğümlere	negatif kenarda çalışır, negatif döngüyü bulur; Dijkstra'dan yavaş
Floyd-Warshall	tüm çiftler arası	negatif kenarda çalışır; negatif döngüyü köşegenden tespit eder
A*	başlangıçtan hedefe	sezgisel (heuristic) tahminle aramayı hızlandırır
BFS	kaynaktan tüm düğümlere	yalnızca ağırlıksız (ya da eşit ağırlıklı) çizgeler

Giriş

Temel İşlem: Gevşetme (Relaxation)

Her düğüm için iki bilgi tutulur:

d[v]: şimdiye kadar bulunan en kısa yol tahmini (başta ∞, kaynakta 0)
π[v]: bu yolda v'den önceki düğüm (önceki, predecessor)

RELAX(u, v, w):
  eğer d[u] + w(u, v) < d[v]:
    d[v] = d[u] + w(u, v)
    π[v] = u

d[u] + w = 5 + 3 = 8 < 9 → d[v] = 8, π[v] = u

Bu bölümdeki tüm algoritmalar gevşetmeyi kullanır; fark, kenarları hangi sırayla ve kaç kez gevşettikleridir. d[v] yalnızca azalabilir ve hiçbir zaman gerçek δ(s, v)'nin altına inmez.

Giriş

En Kısa Yolların Özellikleri

Optimal alt yapı

En kısa yolun her alt yolu da en kısa yoldur. s ⇝ u ⇝ v en kısaysa s ⇝ u parçası da en kısadır. Dinamik programlama ve açgözlü yaklaşım buna dayanır.

Üçgen eşitsizliği

Her (u, v) kenarı için δ(s, v) ≤ δ(s, u) + w(u, v). Gevşetme bu eşitsizliği bozan kenarları düzeltir.

Negatif döngü

Toplam ağırlığı negatif olan bir döngü kaynaktan ulaşılabiliyorsa, döngüde dolaştıkça yol kısalır: en kısa yol tanımsızdır (−∞).

Basit yol

Negatif döngü yoksa en kısa yol döngü içermez; en fazla V − 1 kenarlıdır. Bellman-Ford'un V − 1 turu buradan gelir.

Yolu geri kurmak için π dizisi kullanılır: hedeften başlayıp π[v] ile kaynağa kadar geri gidilir; elde edilen düğümler ters sırada yazılır. Tüm π kenarları birlikte bir en kısa yol ağacı oluşturur.

Dijkstra

Dijkstra Algoritması

Kaynak düğümden diğer tüm düğümlere olan en kısa yolları bulur (tek kaynaklı).
1956'da Edsger W. Dijkstra tarafından geliştirildi, 1959'da yayımlandı.
Yalnızca negatif olmayan ağırlıklı kenarlardan oluşan çizgelerde doğru çalışır.
Açgözlü (greedy): her adımda, henüz kesinleşmemiş düğümler arasından d değeri en küçük olanı seçer ve kesinleştirir.
Seçilen düğümün komşuları gevşetilir.

Sezgi: su dalgasıKaynağa bir taş atıldığını düşünün. Dalga, düğümlere uzaklık sırasıyla ulaşır: önce en yakın düğüm, sonra bir sonraki… Dijkstra düğümleri tam da bu sırayla kesinleştirir. Kesinleşen düğümlerin kümesine S denir.

Dijkstra

Dijkstra: Algoritma Adımları

Adım 1: Başlangıç düğümü seçilir, uzaklığı 0 atanır; diğer tüm düğümlerin uzaklığı ∞ olur.

İlklendirme: d[s] = 0, d[v] = ∞, π[v] = tanımsız, S = ∅.

Adım 2: Seçilen düğümden başlayarak, henüz işlenmemiş komşulara olan uzaklıklar hesaplanır.

Komşu v için aday uzaklık: d[u] + w(u, v).

Adım 3: Daha kısa bir yol bulunursa komşunun uzaklığı güncellenir (gevşetme).

d[u] + w(u, v) < d[v] ise d[v] ve π[v] değişir.

Adım 4: İşlenen düğüm işaretlenir (S'ye eklenir) ve uzaklığı en küçük işaretsiz düğüm seçilir.

Seçim, dizi ya da öncelik kuyruğu (priority queue) ile yapılır.

Adım 5: Tüm düğümler işlenene kadar Adım 2–4 tekrarlanır.

Ulaşılamayan düğümlerin uzaklığı ∞ olarak kalır.

Dijkstra

Dijkstra Örnek 1: Yönsüz Çizge, Kaynak 1

düğüm	d	π
1	0	–
2	∞	–
3	∞	–
4	∞	–
5	∞	–
6	∞	–

İlklendirme: kaynak 1, d[1] = 0, diğerleri ∞. Hiçbir düğüm kesinleşmedi.

düğüm	d	π
1	0	–
2	∞	–
3	∞	–
4	∞	–
5	∞	–
6	∞	–

Kesinleşmemişler içinde en küçük d: 1 (d = 0) seçilir ve kesinleşir.

düğüm	d	π
1	0	–
2	7	1
3	∞	–
4	∞	–
5	∞	–
6	∞	–

Kenar (1, 2): d[1] + 7 = 7 < ∞ → d[2] = 7, π[2] = 1.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	∞	–
5	∞	–
6	∞	–

Kenar (1, 3): d[1] + 9 = 9 < ∞ → d[3] = 9, π[3] = 1.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	∞	–
5	∞	–
6	14	1

Kenar (1, 6): d[1] + 14 = 14 < ∞ → d[6] = 14, π[6] = 1.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	∞	–
5	∞	–
6	14	1

Kesinleşmemişler içinde en küçük d: 2 (d = 7) seçilir ve kesinleşir. Kesinleşmiş komşular (1) atlanır.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	∞	–
5	∞	–
6	14	1

Kenar (2, 3): d[2] + 10 = 17 ≥ 9 → değişiklik yok.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	22	2
5	∞	–
6	14	1

Kenar (2, 4): d[2] + 15 = 22 < ∞ → d[4] = 22, π[4] = 2.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	22	2
5	∞	–
6	14	1

Kesinleşmemişler içinde en küçük d: 3 (d = 9) seçilir ve kesinleşir. Kesinleşmiş komşular (1, 2) atlanır.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	∞	–
6	14	1

Kenar (3, 4): d[3] + 11 = 20 < 22 → d[4] = 20, π[4] = 3.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	∞	–
6	11	3

Kenar (3, 6): d[3] + 2 = 11 < 14 → d[6] = 11, π[6] = 3.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	∞	–
6	11	3

Kesinleşmemişler içinde en küçük d: 6 (d = 11) seçilir ve kesinleşir. Kesinleşmiş komşular (1, 3) atlanır.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	20	6
6	11	3

Kenar (6, 5): d[6] + 9 = 20 < ∞ → d[5] = 20, π[5] = 6.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	20	6
6	11	3

Kesinleşmemişler içinde en küçük d: 4 (d = 20) seçilir ve kesinleşir. (4 ve 5 eşit: 20; küçük numaralı 4 alındı.) Kesinleşmiş komşular (2, 3) atlanır.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	20	6
6	11	3

Kenar (4, 5): d[4] + 6 = 26 ≥ 20 → değişiklik yok.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	20	6
6	11	3

Kesinleşmemişler içinde en küçük d: 5 (d = 20) seçilir ve kesinleşir. Kesinleşmiş komşular (4, 6) atlanır.

düğüm	d	π
1	0	–
2	7	1
3	9	1
4	20	3
5	20	6
6	11	3

Bitti: 1'den uzaklıklar 2:7, 3:9, 6:11, 4:20, 5:20. Yeşil kenarlar en kısa yol ağacını oluşturur (ör. 1 → 3 → 6 → 5).

Dijkstra

Dijkstra Örnek 2: Yönlü Çizge, Q ve S Kümeleri

d	u	π
0	5	/
∞	1	/
∞	2	/
∞	3	/
∞	4	/

u	d	π

İlklendirme: kaynak 5'in uzaklığı 0, diğerleri ∞. Tüm düğümler Q'da, S = ∅.

d	u	π
2	4	5
4	2	5
∞	1	/
∞	3	/

u	d	π
5	0	/

Adım 1: Q'dan 5 alınır, d = 0 ile S'ye konur. Gevşetme: (5,2): ∞ → 4; (5,4): ∞ → 2.

d	u	π
3	2	4
3	3	4
∞	1	/

u	d	π
5	0	/
4	2	5

Adım 2: Q'dan 4 alınır, d = 2 ile S'ye konur. Gevşetme: (4,2): 4 → 3; (4,3): ∞ → 3.

d	u	π
3	3	4
6	1	2

u	d	π
5	0	/
4	2	5
2	3	4

Adım 3: Q'dan 2 alınır, d = 3 ile S'ye konur. Gevşetme: (2,1): ∞ → 6. (2 ve 3 eşit: 3; küçük numaralı 2 alındı.)

d	u	π
6	1	2

u	d	π
5	0	/
4	2	5
2	3	4
3	3	4

Adım 4: Q'dan 3 alınır, d = 3 ile S'ye konur. Gevşetme: (3,4): 4 zaten S'de. Daha kısa yol çıkmaz (gevşetme yok).

d	u	π

u	d	π
5	0	/
4	2	5
2	3	4
3	3	4
1	6	2

Adım 5: Q'dan 1 alınır, d = 6 ile S'ye konur. Gevşetme: (1,3): 3 zaten S'de; (1,4): 4 zaten S'de. Daha kısa yol çıkmaz (gevşetme yok).

	1	2	3	4	5
d	6	3	3	2	0
π	2	4	4	5	/

Son durum: 5'ten en kısa yollar. Yalnızca π kenarları (yeşil) kalır: 5→4→2→1 (6), 5→4→3 (3).

Dijkstra

Dijkstra: Sözde Kod

DIJKSTRA(G, kaynak):
  mesafeler = [ ]; ziyaretEdildi = [ ]
  öncelikKuyruğu = { }
  her bir v için V içinde:
    mesafeler[v] = sonsuz
    ziyaretEdildi[v] = 0
  mesafeler[kaynak] = 0
  öncelikKuyruğu.ekle(kaynak, 0)
  döngü öncelikKuyruğu boş değil iken:
    u = öncelikKuyruğu.çıkar()   // en küçük mesafe
    eğer ziyaretEdildi[u] == 0:
      ziyaretEdildi[u] = 1
      her bir (u, v) için G[u] içinde:
        eğer mesafeler[u] + ağırlık(u, v) < mesafeler[v]:
          mesafeler[v] = mesafeler[u] + ağırlık(u, v)
          öncelikKuyruğu.ekle(v, mesafeler[v])
  döndür mesafeler

Tembel silme: bir düğüm kuyruğa birden çok kez girebilir; eski kayıt çıkarıldığında ziyaretEdildi kontrolü onu atlar. Yol için gevşetmede önceki[v] = u da saklanır.

Dijkstra

Dijkstra (Öncelik Kuyruğu): Kodu Adım Adım İzle

void dijkstra(int kaynak) {
  int[] uzaklik = new int[V + 1];
  int[] onceki = new int[V + 1];
  boolean[] ziyaret = new boolean[V + 1];
  Arrays.fill(uzaklik, SONSUZ);
  uzaklik[kaynak] = 0;
  PriorityQueue<int[]> kuyruk =
    new PriorityQueue<>((a, b) -> a[1] - b[1]);
  kuyruk.add(new int[] { kaynak, 0 });
  while (!kuyruk.isEmpty()) {
    int u = kuyruk.poll()[0];
    if (ziyaret[u]) continue; // eski kayıt
    ziyaret[u] = true;
    for (Kenar k : komsu.get(u)) {
      int v = k.hedef, w = k.agirlik;
      if (!ziyaret[v]
          && uzaklik[u] + w < uzaklik[v]) {
        uzaklik[v] = uzaklik[u] + w;
        onceki[v] = u;
        kuyruk.add(new int[] { v, uzaklik[v] });
      }
    }
  }
}

Diziler kurulur (düğümler 1..5, indis 0 kullanılmaz); uzaklik[5] = 0 ve (5, 0) kuyruğa eklenir.

Kuyruktan en küçük uzaklıklı kayıt (5, 0) alınır: u = 5.

5 kesinleşir: ziyaret[5] = true.

Kenar 5→2 (w = 4): 0 + 4 < ∞ → koşul doğru.

uzaklik[2] = 4, onceki[2] = 5; (2, 4) kuyruğa eklenir.

Kenar 5→4 (w = 2): 0 + 2 < ∞ → koşul doğru.

uzaklik[4] = 2, onceki[4] = 5; (4, 2) kuyruğa eklenir.

Kuyruktan en küçük uzaklıklı kayıt (4, 2) alınır: u = 4.

4 kesinleşir: ziyaret[4] = true.

Kenar 4→2 (w = 1): 2 + 1 < 4 → koşul doğru.

uzaklik[2] = 3, onceki[2] = 4; (2, 3) kuyruğa eklenir.

Kenar 4→3 (w = 1): 2 + 1 < ∞ → koşul doğru.

uzaklik[3] = 3, onceki[3] = 4; (3, 3) kuyruğa eklenir.

Kuyruktan en küçük uzaklıklı kayıt (2, 3) alınır: u = 2.

2 kesinleşir: ziyaret[2] = true.

Kenar 2→1 (w = 3): 3 + 3 < ∞ → koşul doğru.

uzaklik[1] = 6, onceki[1] = 2; (1, 6) kuyruğa eklenir.

Kuyruktan en küçük uzaklıklı kayıt (3, 3) alınır: u = 3.

3 kesinleşir: ziyaret[3] = true.

Kenar 3→4 (w = 2): ziyaret[4] = true → koşul yanlış.

Kuyruktan en küçük uzaklıklı kayıt (2, 4) alınır: u = 2.

ziyaret[2] zaten true: bu, 2'nin eski (2, 4) kaydı → continue ile atlanır (tembel silme).

Kuyruktan en küçük uzaklıklı kayıt (1, 6) alınır: u = 1.

1 kesinleşir: ziyaret[1] = true.

Kenar 1→3 (w = 6): ziyaret[3] = true → koşul yanlış.

Kenar 1→4 (w = 3): ziyaret[4] = true → koşul yanlış.

Kuyruk boş: döngü biter. uzaklik = [6, 3, 3, 2, 0], onceki = [2, 4, 4, 5, –].

Dijkstra

Yolu Geri Kurma: π (önceki) Dizisi

Örnek 2'nin sonucu: π = [2, 4, 4, 5, /]. Hedef 1 için geriye doğru:

1 ← π[1] = 2 ← π[2] = 4 ← π[4] = 5 (kaynak)

Ters çevrilince yol: 5 → 4 → 2 → 1, uzunluk 2 + 1 + 3 = 6 = d[1].

void yolYaz(int[] onceki, int kaynak, int hedef) {
  Deque<Integer> yigin = new ArrayDeque<>();
  for (int v = hedef; v != kaynak; v = onceki[v])
    yigin.push(v);         // hedeften geriye
  yigin.push(kaynak);
  while (!yigin.isEmpty())
    System.out.print(yigin.pop() + " ");
}

Yığın (stack) geriye doğru toplanan düğümleri doğru sıraya çevirir.

Dijkstra

Dijkstra: Algoritma Karmaşıklığı

Maliyet, en küçük uzaklıklı düğümü seçme işleminin nasıl yapıldığına bağlıdır:

Seçim yapısı	Seçim	Gevşetme	Toplam	Uygun çizge
Dizi (doğrusal tarama)	V × O(V)	E × O(1)	O(V²)	yoğun (E ≈ V²)
İkili yığın (öncelik kuyruğu)	O(log V)	O(log V)	O((V + E) log V)	seyrek (E ≪ V²)
Fibonacci yığını	O(log V) amortize	O(1) amortize	O(E + V log V)	kuramsal en iyi

Sayısal örnekV = 10⁴, E = 5·10⁴ (yol ağı): dizi ≈ 10⁸ işlem, yığın ≈ 6·10⁴ · 14 ≈ 8,4·10⁵ işlem.

Bellekd, π ve ziyaret dizileri O(V); tembel silmeli kuyrukta en fazla E kayıt → O(V + E).

Dijkstra

Dijkstra Neden Negatif Kenarda Yanılır?

Doğruluk kanıtı şuna dayanır: kesinleşen u için, S dışından geçen her yol en az d[u] uzunluğundadır; çünkü kenarlar negatif değildir ve yol yalnızca uzayabilir.
Negatif kenar bu varsayımı bozar: sonradan işlenen bir düğüm, kesinleşmiş bir düğüme daha kısa yol açabilir.
Tüm ağırlıklara sabit eklemek de çözüm değildir: çok kenarlı yollar daha fazla ceza alır, en kısa yol değişir.
Negatif kenar varsa Bellman-Ford kullanılır.

A kesinleşir; gevşetme ile d[B] = 2, d[C] = 3.

En küçük d: B (2). Dijkstra B'yi kesinleştirir: “B'ye daha kısa yol olamaz” varsayımı.

C işlenir: d[C] + (−2) = 1 < 2, ama B zaten S'de. Sonuç d[B] = 2 yanlış; gerçek δ(A, B) = 1 (A → C → B).

Bellman-Ford

Bellman-Ford Algoritması

Kaynak düğümden diğer tüm düğümlere olan en kısa yolları bulur (tek kaynaklı).
Richard Bellman (1958) ve Lester Ford Jr. (1956) adlarını taşır; E. F. Moore da 1959'da aynı yöntemi verdi.
Negatif ağırlıklı kenarları işleyebilir.
Kaynaktan ulaşılabilen negatif döngüleri tespit edebilir.
Dijkstra'dan yavaştır: O(V · E).

Algoritma ilkeleriHer düğüm için en kısa yol tahminlerini tutan bir dizi kullanır. Başta tüm tahminler ∞, kaynak 0'dır. Çizgedeki tüm kenarlar teker teker incelenir ve tahminler güncellenir; bu tarama V − 1 kez tekrarlanır. Düğüm seçimi yoktur, açgözlü değildir.

Bellman-Ford

Bellman-Ford: Algoritma Adımları

Adım 1: Başlangıç düğümüne uzaklık 0, diğer düğümlere ∞ atanır.

π[v] = tanımsız.

Adım 2: Kenarlar tek tek incelenir, düğümler arası uzaklıklar gevşetme ile güncellenir; bu tur V − 1 kez tekrarlanır.

Bir turda kenar sırası sabittir; sıra sonucu değil, kaç turda yakınsayacağını etkiler.

Adım 3: Bir düğümün uzaklığı güncellenirse, sonraki incelemelerde onun komşularının uzaklıkları da güncellenebilir.

İyileşme, yol boyunca her turda en az bir kenar ilerler.

Adım 4: Negatif döngü kontrolü için tüm kenarlar bir kez daha incelenir; hâlâ gevşeyen kenar varsa negatif döngü vardır.

Döngü yoksa V − 1 turdan sonra hiçbir kenar gevşemez.

Bellman-Ford

Neden V − 1 Tur? Karmaşıklık

Negatif döngü yoksa her en kısa yol en fazla V − 1 kenarlıdır.
Değişmez: i. turun sonunda, en fazla i kenarlı en kısa yolu olan her v için d[v] = δ(s, v).
Tur i'de yolun i. kenarı mutlaka gevşetilir; V − 1 tur tüm yolları tamamlar.
Her tur E kenarı inceler: toplam O(V · E) zaman, O(V) ek bellek.

Çizge	Zaman
Seyrek, E ≈ V	O(V²)
Yoğun, E ≈ V²	O(V³)
En iyi durum (erken durma)	O(E)

Erken durma: bir turda hiçbir d değişmezse sonraki turlar da değiştirmez; döngüden çıkılabilir.

Bellman-Ford