• Euler Yolu: Çizgedeki her kenardan tam olarak bir kez geçen yol.
• Hamilton Yolu: Çizgedeki her düğümü tam olarak bir kez ziyaret eden yol.

İlk bakışta birbirine benzer görünen bu iki kavram aslında tamamen farklı zorluktadır. Bir çizgenin Euler yolu içerip içermediğini belirlemek ve varsa bulmak çok verimli biçimde yapılabilir. Hamilton yolu ise NP-hard bir problemdir; bunu verimli çözen bilinen bir algoritma yoktur. ``

19.1 Euler Yolu

Euler yolu, çizgedeki her kenardan tam olarak bir kez geçen yoldur. Euler, bu tür yolları 1736’da Königsberg Köprüleri sorusunu araştırırken keşfetmiştir; bu olay çizge teorisinin doğuş noktası olarak kabul edilir.

Bir Euler yolunun aynı düğümde başlayıp bitmesi durumuna Euler devresi denir.

Euler Yolu Varlık Koşulları

Yönsüz Çizgeler

Tüm kenarlar aynı bağlı bileşende olduğu varsayılarak:

• Her düğümün derecesi çiftse → Euler devresi vardır (yani her Euler yolu aynı zamanda devredir).
• Tam olarak iki düğümün derecesi tekse, kalanlar çiftse → Euler yolu vardır fakat devre yoktur; yol tek dereceli iki düğüm arasında uzanır.

Başka hiçbir durumda Euler yolu mevcut değildir.

Örneğin 1, 3 ve 4. düğümlerin derecesi 2 (çift), 2 ve 5. düğümlerin derecesi 3 (tek) olan bir çizgede 2. düğümden 5. düğüme bir Euler yolu bulunur; ancak Euler devresi mevcut değildir.

Yönlü Çizgeler

Tüm kenarlar aynı bileşende olduğu varsayılarak:

• Her düğümde iç derece = dış derece → Euler devresi vardır.
• Bir düğümde dış derece = iç derece + 1 (başlangıç), bir düğümde iç derece = dış derece + 1 (bitiş), geri kalanlar eşit → Euler yolu vardır, devre yoktur.

Örneğin 1, 3 ve 4. düğümlerin hem iç hem dış derecesi 1 olan; 2. düğümün iç derecesi 1, dış derecesi 2 olan; 5. düğümün iç derecesi 2, dış derecesi 1 olan bir çizge, 2. düğümden 5. düğüme bir Euler yolu içerir.

Hierholzer’in Algoritması

Hierholzer’in Algoritması, Euler devresi bulmak için $O(n + m)$ zamanda çalışan verimli bir yöntemdir. Çizgenin Euler devresi içermesi gerekir; aksi hâlde algoritma çalışmaz. Çizgede yalnızca Euler yolu varsa, iki tek dereceli düğüm arasına yapay bir kenar eklenerek Euler devresine dönüştürülüp algoritma uygulanabilir.

Algoritma şu şekilde ilerler:

1. Başlangıç düğümünden hareket ederek çizgenin bir kısmını kapsayan bir devre oluştur.
2. Devrede yer alıp henüz devreye katılmamış komşusu bulunan bir $x$ düğümü bul.
3. $x$ düğümünden başlayıp devrede olmayan kenarlarla ilerle; sonunda $x$’e geri dönerek bir alt devre oluştur.
4. Bu alt devreyi ana devreye ekle.
5. Tüm kenarlar devreye girinceye kadar tekrarla.

Örnek

Aşağıdaki çizgede algoritma adım adım şöyle ilerler:

        1
      / | \
     2  3  4
     |  |  |
     5  6  7

• Adım 1: 1. düğümden $1 \to 2 \to 3 \to 1$ devresi oluşturulur.
• Adım 2: 2. düğümünden $2 \to 5 \to 6 \to 2$ alt devresi ana devreye eklenir.
• Adım 3: 6. düğümünden $6 \to 3 \to 4 \to 7 \to 6$ alt devresi ana devreye eklenir.

Tüm kenarlar devreye eklendiğinden Euler devresi başarıyla elde edilir.

19.2 Hamilton Yolları

Hamilton yolu, çizgedeki her düğümü tam olarak bir kez ziyaret eden yoldur. Aynı düğümde başlayıp bitiyorsa Hamilton devresi adını alır.

Varlık Koşulları

Bir çizgenin Hamilton yolu içerip içermediğini verimli biçimde belirlemenin yolu yoktur; bu problem NP-hard‘dır. Yine de bazı özel durumlarda Hamilton yolunun varlığı garantilenebilir:

• Tam çizgeler: Her iki düğüm arasında kenar varsa Hamilton yolu her zaman mevcuttur.
• Dirac’ın Teoremi: Her düğümün derecesi en az $n/2$ ise çizge Hamilton yolu içerir.
• Ore’nin Teoremi: Komşu olmayan her düğüm çiftinin derece toplamı en az $n$ ise çizge Hamilton yolu içerir.

Bu teoremlerin ortak paydası şudur: çizge ne kadar çok kenar içerirse Hamilton yolu bulunma olasılığı o kadar artar. Teoremler yalnızca yeterlilik koşulu sunar; tersinin garantisi yoktur.

Hamilton Yolunun Bulunması

Varlığı bile verimli belirlenemeyen Hamilton yolunu bulmak da aynı şekilde zorludur. İki yaklaşım vardır:

Geri izleme (backtracking): Tüm olası düğüm sıralamaları denenir. Zaman karmaşıklığı $O(n!)$’dir; küçük $n$ değerleri için kullanılabilir.

Dinamik programlama: $\text{possible}(S, x)$ fonksiyonu, $S$ düğüm alt kümesini dolaşıp $x$ düğümünde biten bir Hamilton yolunun var olup olmadığını gösterir. $S$ bir bit maskesiyle temsil edilir ve fonksiyon aşağıdaki özyinelemeyle hesaplanır:

Bu yaklaşım $O(2^n n^2)$ zamanda çalışır; geri izlemeye kıyasla çok daha hızlıdır (bkz. Bölüm 10.5).

19.3 De Bruijn Dizileri

De Bruijn dizisi, $k$ karakterden oluşan alfabe üzerinde $n$ uzunluğundaki her alt yazıyı tam olarak bir kez içeren dairesel bir dizdir. Doğrusal biçimde yazıldığında uzunluğu $k^n + n - 1$ olur.

Örneğin $n = 3$, $k = 2$ için bir De Bruijn dizisi:

Bu dizi ${0, 1}$ alfabesi üzerindeki tüm 3 bitlik dizileri tam birer kez içerir: $000, 001, 010, 011, 100, 101, 110, 111$.

Euler Yolu Bağlantısı

De Bruijn dizisi inşa etmek, bir çizgede Euler yolu bulmaya indirgenir. Çizgenin düğümleri $n - 1$ karakterlik tüm yazılara, kenarlar ise bu yazılara bir karakter ekleyerek elde edilen $n$ karakterlik geçişlere karşılık gelir.

Örneğin $n = 3$, $k = 2$ için dört düğüm vardır: $00, 01, 10, 11$. $00$ düğümünden $0$ karakteri eklenince $00$ düğümüne ($000$), $1$ eklenince $01$ düğümüne ($001$) gidilir. Bu çizgedeki her Euler yolu tüm $n$ uzunluğundaki alt yazıları tam birer kez kapsar.

Yazının uzunluğu: başlangıç düğümünün $n - 1$ karakteri ile $k^n$ kenardaki karakterlerin toplamından $k^n + n - 1$ olur.

19.4 Atın Turları

Atın turu, bir satranç atının $n \times n$ tahtada her kareyi tam bir kez ziyaret ettiği hareket dizisidir. At başladığı kareye dönüyorsa kapalı tur, dönmüyorsa açık tur denir.

Örneğin $5 \times 5$ tahtadaki bir açık at turu:

 1  4 11 16 25
12 17  2  5 10
 3 20  7 24 15
18 13 22  9  6
21  8 19 14 23

At turu, kareler düğüm ve at hareketiyle ulaşılabilecek kareler kenar olarak modellenen bir çizgede Hamilton yoluna karşılık gelir.

Warnsdorf’un Kuralı

Warnsdorf’un Kuralı, at turu bulmak için basit ve etkili bir sezgisel (heuristic) yöntemdir (1823). Temel fikir şudur: atı her adımda, oradan yapılabilecek hareket sayısı en az olan kareye götür.

Örneğin beş farklı kare arasından seçim yapılacak bir durumda, birinden yalnızca 1 hamle yapılabiliyorsa Warnsdorf kuralı atı o kareye yönlendirir; böylece “çıkmaz sokak” riski en aza indirilir.

Bu yaklaşım büyük tahtalarda dahi pratik sürelerde tur bulmayı mümkün kılar. At turu için polinom zamanlı algoritmalar da geliştirilmiştir; ancak bunlar çok daha karmaşıktır.

• Bir düğümün $k$. atası hangi düğümdür?
• Bir alt ağaçtaki değerlerin toplamı kaçtır?
• İki düğüm arasındaki yolda bulunan değerlerin toplamı kaçtır?
• İki düğümün en yakın ortak atası hangisidir? ``

18.1 Ataları Bulmak

Köklü bir ağaçta $x$ düğümünün $k$. atası, $x$’ten $k$ defa yukarı çıkıldığında ulaşılan düğümdür. $\text{ancestor}(x, k)$ ile gösterilir; eğer bu ata yoksa değer $0$ kabul edilir. Örneğin bir ağaçta $\text{ancestor}(2, 1) = 1$ ve $\text{ancestor}(8, 2) = 4$ olabilir.

Naif yöntemle $\text{ancestor}(x, k)$, ağaçta $k$ adım yukarı çıkılarak bulunur; ancak bu $O(k)$ zaman alır ve $n$ düğümlü bir zincir şeklindeki ağaçta oldukça yavaş kalabilir.

İkili kaldırma (binary lifting) ile Bölüm 16.3’teki ardıl yol tekniğine benzer biçimde $\text{ancestor}(x, k)$ değeri $O(\log k)$ zamanda hesaplanabilir. Her düğüm için $2$’nin kuvvetlerine karşılık gelen atalar önceden hesaplanır:

Ön işleme $O(n \log n)$ zaman alır; her düğüm için $O(\log n)$ değer hesaplanır. Ardından herhangi bir $\text{ancestor}(x, k)$ değeri, $k$’yı $2$’nin kuvvetlerinin toplamı olarak ifade ederek $O(\log k)$ zamanda bulunabilir.

18.2 Alt Ağaçlar ve Yollar

Ağaç dolaşma dizisi (tree traversal array), köklü bir ağacın düğümlerini kök düğümünden başlayan DFS ziyaret sırasına göre sıralar. Örneğin aşağıdaki ağaçta:

        1
      / | \ \
     2  3  4  5
     |     |\ 
     6     7 8
             |
             9

DFS sırası ve ağaç dolaşma dizisi şöyle olur:

Alt Ağaç Sorguları

Bir ağaçtaki her alt ağaç, dolaşma dizisinin ardışık bir alt dizisine karşılık gelir. Bu alt dizinin ilk elemanı alt ağacın kök düğümüdür. Örneğin 4. düğümün alt ağacı aşağıdaki vurgulanan bölüme denk gelir:

Bu yapıyı kullanarak şu iki sorguyu verimli biçimde çözebiliriz:

• Bir düğümün değerini güncelle.
• Bir düğümün alt ağacındaki değerlerin toplamını hesapla.

Her düğüm için üç değer tutan bir dolaşma dizisi oluşturulur: düğüm kimliği, alt ağaç büyüklüğü ve düğümün değeri. Örnek ağaç için:

1. düğümün alt ağaç toplamı alt ağaç büyüklüğü sayesinde doğrudan tespit edilir: $3 + 4 + 3 + 1 = 11$. Bu sorguları $O(\log n)$ sürede çözmek için değerleri bir ikili indeksli ağaç (binary indexed tree / Fenwick tree) ya da bölüm ağacı (segment tree) üzerinde tutmak yeterlidir.

Yol Sorguları

Ağaç dolaşma dizisi, kök düğümden herhangi bir düğüme uzanan yoldaki değerlerin toplamını bulmak için de kullanılabilir. Çözülmek istenen sorgular:

• Bir düğümün değerini değiştir.
• Kökten bir düğüme uzanan yoldaki değerlerin toplamını hesapla.

Bu kez dolaşma dizisinin son satırında her düğüm için köke olan yol toplamı tutulur:

Bir düğümün değeri $x$ arttırıldığında, onun alt ağacındaki tüm düğümlerin yol toplamı $x$ kadar artar. Örneğin 4. düğümün değeri 1 arttırılırsa:

Bu işlem bir aralıktaki tüm değerleri artırma ve tekil bir değeri okuma sorgusuna dönüşür; her ikisi de ikili indeksli ağaç veya bölüm ağacı ile $O(\log n)$ zamanda yapılabilir (bkz. Bölüm 9.4).

18.3 En Yakın Ortak Ata (LCA)

İki düğümün en yakın ortak atası (Lowest Common Ancestor, LCA), köklü ağaçta her iki düğümü de alt ağacında barındıran en alttaki düğümdür. Örneğin 5 ve 8. düğümünün LCA’sı 2. düğümdür.

1. Yöntem: İkili Kaldırma

Bu yöntem, $k$. atayı verimli bulan ön işlemeye (18.1) dayanır. İki adımdan oluşur:

Adım 1 — Aynı derinliğe getir: İki düğümü gösteren işaretçiler tutulur. Daha derinde olan işaretçi, diğeriyle aynı derinliğe gelene kadar yukarı taşınır. Örneğin 8. düğümü gösteren işaretçi bir seviye yukarı çıkıp 6. düğümü gösterince 5. düğümle aynı seviyeye ulaşır.

Adım 2 — Birlikte yukarı çık: İki işaretçi aynı düğüme ulaşana kadar gereken minimum adım sayısı ikili kaldırmayla hesaplanır; her iki işaretçi bu kadar yukarı taşınır. İşaretçilerin buluştuğu düğüm LCA’dır.

Her iki adım da $O(\log n)$ zamanda çalışır.

2. Yöntem: Euler Turu

Bu yöntemde DFS sırasında her düğüm yalnızca ilk ziyarette değil, her ziyarette diziye eklenir. $k$ çocuğu olan bir düğüm dizide $k + 1$ kez yer alır; dolayısıyla toplam dizi uzunluğu $2n - 1$ olur.

Dizi iki değer tutar: düğüm kimliği ve derinlik. Örnek ağaç için dizi:

$a$ ve $b$ düğümlerinin LCA’sı, dizide $a$ ile $b$’nin konumları arasındaki minimum derinlikli düğüme karşılık gelir. Örneğin 5. düğüm dizinin 2. indeksinde, 8. düğüm ise 5. indeksindedir. $[2, 5]$ aralığında minimum derinlik 2 olup bu 3. indeksteki 2. düğüme karşılık gelir; dolayısıyla LCA = 2.

Bu sayede LCA sorgusu bir aralık minimum sorgusuna dönüşür. Dizi statik olduğundan $O(n \log n)$ ön işlemeyle sonraki her sorgu $O(1)$ zamanda yanıtlanabilir.

Düğümler Arası Mesafe

$a$ ile $b$ arasındaki mesafe, LCA bulunduktan sonra şu formülle hesaplanır:

Örneğin 5 ve 8. düğümler için LCA = 2, $\text{depth}(5) = 3$, $\text{depth}(8) = 4$, $\text{depth}(2) = 2$ olduğundan:

18.4 Çevrimdışı Algoritmalar

Şimdiye kadar incelenen algoritmalar çevrimiçidir; yani her sorguyu bir sonraki gelmeden yanıtlayabilirler. Ancak pek çok problemde bu özellik zorunlu değildir. Çevrimdışı algoritmalarda tüm sorgular önceden bilinir ve herhangi bir sırayla yanıtlanabilir; bu da genellikle daha kolay implementasyona olanak tanır.

Veri Yapılarını Birleştirmek

Çevrimdışı yaklaşımın bir yolu, DFS sırasında her düğümde bir veri yapısı $d[s]$ oluşturmak ve çocukların veri yapılarını bu yapıyla birleştirmektir.

Örneğin şu problemi düşünelim: her düğümde bir değer bulunan ağaçta, “$s$ düğümünün alt ağacında $x$ değerine sahip kaç düğüm var?” sorgularını yanıtlamak istiyoruz. Çözüm için map veri yapısı kullanılabilir.

Naif yaklaşımda her düğüm için baştan bir map oluşturmak çok yavaş olur. Bunun yerine her $s$ düğümü için yalnızca kendi değerini içeren bir başlangıç $d[s]$ oluşturulur; ardından her çocuk $u$ için $d[u]$ ile $d[s]$ birleştirilir. Birleştirme sırasında $d[s]$, $d[u]$’dan küçükse önce yer değiştirme yapılır:

swap(a, b);

Bu fonksiyon, C++ standart kütüphanesi veri yapıları için sabit zamanda çalışır. Bu strateji sayesinde her değer ağaç dolaşımı boyunca en fazla $O(\log n)$ kez kopyalanır ve algoritma verimli kalır.

Çevrimdışı LCA: Tarjan’ın Algoritması

En yakın ortak ataları çevrimdışı bulmak için Tarjan’ın Algoritması kullanılabilir. Bu algoritma, union-find yapısı üzerine kurulu olup (bkz. Bölüm 15.2) bölümün başında anlatılan çevrimiçi yöntemlere kıyasla daha kolay koda dökülebilir.

Girdi olarak düğüm çiftleri alınır ve her çift için LCA hesaplanır. Algoritma DFS ile ağacı dolaşırken ayrık gruplar tutar; başlangıçta her düğüm ayrı bir gruptadır. Her grup için o gruptaki en üstteki düğüm kaydedilir.

Algoritma bir $x$ düğümünü ziyaret ettiğinde, LCA’sı $x$ ile birlikte sorgulanacak tüm $y$ düğümleri incelenir. Eğer $y$ önceden ziyaret edildiyse, $x$ ve $y$’nin LCA’sı $y$’nin grubundaki en üst düğümdür. $x$ düğümü tamamen işlendikten sonra $x$ ile ebeveyninin grupları birleştirilir.

Örneğin $(5, 8)$ ve $(2, 7)$ çiftlerinin LCA’larını bulmak istediğimiz bir ağaçta:

• Algoritma 8. düğümü ziyaret ettiğinde 5. düğümün önceden ziyaret edildiğini görür; 5’in grubundaki en üst düğüm 2’dir. Dolayısıyla $\text{lca}(5, 8) = 2$.
• Algoritma 7. düğümü ziyaret ettiğinde 2. düğümün önceden ziyaret edildiğini görür; 2’nin grubundaki en üst düğüm 1’dir. Dolayısıyla $\text{lca}(2, 7) = 1$.

Algoritmanın zaman karmaşıklığı, union-find işlemleriyle birlikte pratikte neredeyse lineer olan $O(n \alpha(n))$’dir.

Bir çizge, her düğümden diğer tüm düğümlere gidilebiliyorsa güçlü bağlanılmış (strongly connected) olarak adlandırılır. Güçlü bağlanılmamış bir çizgede ise bazı düğüm çiftleri arasında tek yönlü bir ulaşım bile mümkün olmayabilir.

Güçlü bağlanılmış parçalar (strongly connected components, SCC), çizgeyi olabildiğince büyük güçlü bağlanılmış bölümlere ayırır. Bu parçalar, orijinal çizgenin derin yapısını ortaya koyan asiklik bir bileşen çizgesi (component graph) oluşturur. `` Örneğin bir çizgenin $A = {1, 2}$, $B = {3, 6, 7}$, $C = {4}$ ve $D = {5}$ şeklinde dört güçlü bağlanılmış parçası varsa, bileşen çizgesi bu dört düğüm üzerinde döngüsüz bir yönlü çizge oluşturur. Bu yapı döngü içermediği için 16. Bölümdeki topolojik sıralama ve dinamik programlama teknikleri doğrudan uygulanabilir.

17.1 Kosaraju’nun Algoritması

Kosaraju’nun Algoritması, yönlü bir çizgedeki tüm güçlü bağlanılmış parçaları $O(n + m)$ zamanda bulan verimli bir algoritmadır. İki ayrı DFS (derinlik öncelikli arama) kullanır.

1. Arama

İlk DFS, tüm düğümlerden geçerek her işlenmemiş düğümden bir arama başlatır. Her düğüm tamamen işlendiğinde bir listeye eklenir. Bu listedeki sıra, düğümlerin bitiş zamanlarına göre belirlenir.

Örneğin şu çizgede düğümler şu sırayla işlenip listeye eklenir:

2. Arama

İkinci aşamada çizgedeki tüm kenarlar ters çevrilir. Bu, ikinci aramanın güçlü bağlanılmış parçaların dışına “sızmamasını” garanti eder.

Ardından birinci aramada oluşturulan listedeki düğümler ters sırada ziyaret edilir. İşlenmemiş her düğümden yeni bir parça oluşturulup DFS başlatılır; bu aramada bulunan tüm düğümler söz konusu parçaya eklenir.

Örnek çizgede önce 3. düğümden bir parça oluşturulur. Sonraki düğümler olan 7 ve 6 zaten bu parçaya ait olduğundan atlanır; yeni parça 1. düğümde başlar. En sonda 5 ve 4. düğümler işlenerek kalan parçalar tamamlanır.

Algoritmanın zaman karmaşıklığı $O(n + m)$’dir; iki DFS kullanılmasına karşın her biri lineer zamanda çalışır.

17.2 2SAT Problemi

Güçlü bağlanırlık, 2SAT adı verilen önemli bir mantıksal tatmin problemiyle de doğrudan ilişkilidir. Problemde şu biçimde bir formül verilir:

Burada her $a_i$ ve $b_i$ ya bir mantıksal değişken ($x_1, x_2, \ldots, x_n$) ya da onun karşıtıdır ($\lnot x_1, \lnot x_2, \ldots, \lnot x_n$). Görev, formülü doğru yapacak bir değer ataması bulmak ya da böyle bir atamanın mümkün olmadığını göstermektir.

Örnek 1 (Çözülebilir)

Bu formül aşağıdaki atama ile sağlanır:

Örnek 2 (Çözülemez)

$x_1$ için ne değer verilirse verilsin bir çelişki ortaya çıkar: $x_1 = \text{false}$ ise hem $x_2$ hem $\lnot x_2$ doğru olmalıdır (imkânsız); $x_1 = \text{true}$ ise hem $x_3$ hem $\lnot x_3$ doğru olmalıdır (imkânsız).

Çizge Modeli

2SAT problemi bir çizgeye dönüştürülür. Düğümler $x_i$ ve $\lnot x_i$ değişkenlerini, kenarlar ise değişkenler arası çıkarımları temsil eder. Her $(a_i \lor b_i)$ çifti iki kenar üretir:

Bu, “$a_i$ yanlışsa $b_i$ doğru olmalı, ya da tam tersi” mantığını ifade eder.

$L_1$ için oluşan çizgede $x_i$ ve $\lnot x_i$ hiçbir zaman aynı güçlü bağlanılmış parçada bulunmaz; dolayısıyla bir çözüm mevcuttur. $L_2$ için ise tüm düğümler aynı güçlü bağlanılmış parçaya aittir; dolayısıyla çözüm yoktur.

Genel kural: Formülün bir çözümü vardır ancak ve ancak hiçbir $x_i$ ile $\lnot x_i$ aynı güçlü bağlanılmış parçada bulunmuyorsa.

Çözümü Bulmak

Çözüm mevcutsa değişken değerleri ters topolojik sıraya göre belirlenir. Her adımda, başka işlenmemiş parçalara kenarı olmayan bir parça seçilir:

• Parçadaki değişkenlere henüz değer verilmemişse parçanın konumuna göre değer atanır.
• Değer zaten atanmışsa değiştirilmez.

Bu işlem tüm değişkenlere birer değer verilinceye kadar sürer.

Örneğin $L_1$ için bileşenler $A = {\lnot x_4}$, $B = {x_1, x_2, \lnot x_3}$, $C = {\lnot x_1, \lnot x_2, x_3}$ ve $D = {x_4}$ olarak bulunur. Ters topolojik sırayla önce $D$ işlenir ve $x_4 = \text{true}$ olur. Ardından $C$ işlenir ve $x_1 = \text{false}$, $x_2 = \text{false}$, $x_3 = \text{true}$ atanır. Tüm değişkenler atandığından $A$ ve $B$ parçaları değişkenleri değiştirmez.

Bu yöntemin doğruluğunu şöyle anlayabiliriz: eğer $x_i$ düğümünden $x_j$ düğümüne, oradan da $\lnot x_j$ düğümüne bir yol varsa $x_i$ asla doğru olamaz; çünkü bu durumda $\lnot x_j$ düğümünden $\lnot x_i$ düğümüne de bir yol bulunur ve bu zincirleme çelişki $x_i$’yi zorla yanlış yapar.

Not: 3SAT probleminde her parça $(a_i \lor b_i \lor c_i)$ biçimindedir. Bu problem NP-Hard’dır; yani verimli bilinen bir çözüm algoritması yoktur.

• Asiklik Çizgeler (Acyclic Graphs / DAG): Çizgede hiçbir döngü yoktur; yani bir düğümden kendisine geri dönen bir yol mevcut değildir.
• Varis Çizgeleri (Successor Graphs): Her düğümden çıkan yalnızca 1 kenar vardır, yani her düğümün tam olarak bir ardılı vardır.

Her iki durumda da bu özellikler sayesinde çeşitli verimli algoritmalar tasarlanabilir. ``

16.1 Topolojik Sıralama

Topolojik sıralama, yönlü bir çizgenin düğümlerini belirli bir sıraya koymanın yoludur. Sıralamanın kuralı şudur: eğer $a$ düğümünden $b$ düğümüne bir yol varsa, $a$ sıralamada $b$’den önce yer alır.

Asiklik çizgelerde her zaman en az bir topolojik sıralama vardır. Ancak çizge döngü içeriyorsa topolojik sıralama yapmak mümkün değildir; çünkü döngüdeki hiçbir düğüm sıralamada diğerlerinden önce gelemez.

Algoritma

Fikir, tüm düğümleri ziyaret edip işlenmemiş her düğümden derinlik öncelikli arama (DFS) başlatmaktır. Her düğümün üç olası durumu vardır:

• 0. durum (beyaz): Düğüm henüz işlenmedi.
• 1. durum (açık gri): Düğüm şu anda işleniyor.
• 2. durum (koyu gri): Düğüm tamamen işlendi.

Başlangıçta tüm düğümler 0. durumdadır. Bir düğümde arama başladığında durumu 1’e geçer. Düğümün tüm devam düğümleri işlendiğinde durumu 2 olur ve düğüm bir listeye eklenir. Topolojik sıralama, bu listenin tersidir.

Çizge döngü içeriyorsa arama sırasında durumu 1 olan bir düğümle tekrar karşılaşılır; bu, topolojik sıralamanın yapılamayacağını gösterir.

Örnek 1 (Asiklik Çizge)

Arama 1. düğümden başlayıp 6. düğüme ilerler. 6. düğüm işlenip listeye eklenir; ardından 3, 2 ve 1. düğümler sırasıyla eklenir: liste $[6, 3, 2, 1]$. Sonraki arama 4. düğümde başlar ve $[6, 3, 2, 1, 5, 4]$ listesi oluşur. Listenin tersi olan $[4, 5, 1, 2, 3, 6]$ topolojik sıralamayı verir.

Bir çizgede birden fazla geçerli topolojik sıralama bulunabilir.

Örnek 2 (Döngülü Çizge)

Döngü içeren bir çizgede arama sırasında durumu 1 olan (işlenmekte olan) bir düğüme tekrar ulaşılır. Bu, çizgede topolojik sıralama yapılamayacağının kanıtıdır. Örneğin $2 \to 3 \to 5 \to 2$ döngüsü bunu engeller.

16.2 Dinamik Programlama

Yönlü çizge asiklik ise, dinamik programlama uygulanabilir. Bu teknikle aşağıdaki gibi sorular verimli biçimde cevaplanabilir:

• Başlangıçtan hedefe kaç farklı yol vardır?
• En kısa veya en uzun yol hangisidir?
• Bir yoldaki minimum veya maksimum kenar sayısı nedir?
• Hangi düğümler her yolda kesinlikle geçilir?

Yol Sayısını Hesaplama

$\text{paths}(x)$, 1. düğümden $x$ düğümüne giden yol sayısını temsil etsin. Temel durum $\text{paths}(1) = 1$ olur. Diğer değerler şu özyinelemeyle hesaplanır:

Burada $a_1, a_2, \ldots, a_k$, $x$ düğümüne doğrudan kenar gönderen düğümlerdir. Çizge asiklik olduğu için $\text{paths}(x)$ değerleri topolojik sırayı takip ederek hesaplanabilir.

Örneğin aşağıdaki çizgede 1. düğümden 6. düğüme 3 yol vardır ($1{\to}2{\to}3{\to}6$, $1{\to}4{\to}5{\to}2{\to}3{\to}6$, $1{\to}4{\to}5{\to}3{\to}6$) ve düğümlerin $\text{paths}$ değerleri topolojik sırayla şöyle hesaplanır:

Dijkstra Çıktısı Üzerinde DP

Dijkstra’nın Algoritması’nın yan ürünü olarak bir yönlü asiklik çizge elde edilir; bu çizge her düğüme ulaşan en kısa yolları gösterir. Bu çizge üzerinde dinamik programlama ile örneğin “en kısa yolların sayısı” gibi sorular cevaplanabilir.

Herhangi Bir DP Sorusu Çizge Olarak Gösterilebilir

Her dinamik programlama sorusu, düğümlerin durumları ve kenarların geçişleri temsil ettiği yönlü asiklik bir çizge olarak modellenebilir. Örneğin ${c_1, c_2, \ldots, c_k}$ paralarıyla $n$ miktarını oluşturma problemi böyle bir çizgedir; 0. düğümden $n$. düğüme olan en kısa yol minimum para sayısını, yol sayısı ise toplam çözüm sayısını verir.

16.3 Ardıl Yollar

Ardıl çizgelerde her düğümden yalnızca 1 kenar çıkar. Böyle bir çizge bir veya birkaç parçadan oluşur ve her parça bir döngü ile ona götüren yolları içerir. Ardıl çizgeler bazen fonksiyonel çizge olarak da adlandırılır; çünkü her ardıl çizge, bir düğümü alıp ardılını döndüren bir fonksiyona karşılık gelir.

Örneğin:

$O(\log k)$ ile Ardıl Hesaplama

$\text{succ}(x, k)$, $x$ düğümünden tam olarak $k$ adım atıldığında ulaşılan düğümü verir. Örneğin $\text{succ}(4, 6) = 2$: $4 \to 6 \to 2 \to 5 \to 2 \to 5 \to 2$.

Naif yöntem $O(k)$ zaman alır. Ön işlemeyle tüm $\text{succ}(x, k)$ değerleri $k = 2^i$ kuvvetleri için önceden hesaplanırsa, herhangi bir sorgu $O(\log k)$ zamanda yanıtlanabilir. Özyineleme şöyle kurulur:

Ön işleme $O(n \log u)$ zaman alır; $u$ atılacak maksimum adım sayısıdır. Yukarıdaki çizge için ilk birkaç satır:

Herhangi bir $\text{succ}(x, k)$ için $k$, 2’nin kuvvetlerinin toplamı olarak ifade edilir. Örneğin $11 = 8 + 2 + 1$ olduğundan:

Örneğin $\text{succ}(4, 11) = 5$ bu şekilde $O(\log 11)$ adımda hesaplanır.

16.4 Döngü Bulma

Tek bir yolu olan ve bu yol bir döngüyle biten bir ardıl çizge düşünelim. Başlangıç düğümünden ilerlemeye başladığımızda şu sorular sorulabilir: Döngüdeki ilk düğüm hangisidir? Döngü kaç düğümden oluşur?

Örneğin $1 \to 2 \to 3 \to 4 \to 5 \to 6 \to 4 \to \cdots$ yolunda döngüye giren ilk düğüm 4’tür ve döngü ${4, 5, 6}$ olmak üzere üç düğümden oluşur.

Basit bir yöntem, çizgede ilerleyerek ziyaret edilen tüm düğümleri tutmak ve bir düğüm iki kez görüldüğünde döngünün başladığına karar vermektir. Bu yöntem $O(n)$ zaman ve $O(n)$ bellek kullanır.

Floyd’un Algoritması

Floyd’un Algoritması da $O(n)$ zamanda çalışır; ancak yalnızca $O(1)$ ek bellek kullanır. İki işaretçi $a$ ve $b$ kullanılır; $a$ her adımda 1 ileri, $b$ ise 2 ileri gider:

a = succ(x);
b = succ(succ(x));
while (a != b) {
    a = succ(a);
    b = succ(succ(b));
}

İki işaretçi buluştuğunda $a$ işaretçisi $k$ adım atmıştır ve $b$ işaretçisi $2k$ adım atmıştır. Bu noktada döngünün uzunluğu $k$’yi tam böler. Döngüye giren ilk düğümü bulmak için $a$’yı başlangıç noktasına geri alıp her iki işaretçiyi birer birer ilerletiriz:

a = x;
while (a != b) {
    a = succ(a);
    b = succ(b);
}
first = a;

Son olarak döngünün uzunluğu şöyle hesaplanır:

b = succ(a);
length = 1;
while (a != b) {
    b = succ(b);
    length++;
}

Kapsayan ağacın ağırlığı kenar ağırlıklarının toplamıdır. En küçük kapsayan ağaç (minimum spanning tree), ağırlığı en küçük olan kapsayan ağaçtır. Benzer şekilde en büyük kapsayan ağaç, en büyük ağırlığa sahip kapsayan ağaçtır.

Bir çizgenin birkaç tane en küçük ve en büyük kapsayan ağacı olabilir; yani bu ağaçlardan sadece bir tane olmak zorunda değildir.

En küçük ve en büyük kapsayan ağaçları bazı açgözlü yöntemler kullanarak oluşturabiliriz. Bu bölümde kenarların ağırlıklarına göre sıralayarak yapılan iki algoritmadan bahsedeceğiz. Her ne kadar bölümde en küçük kapsayan ağaçları bulmaya odaklanacak olsak bile, en büyük kapsayan ağaç da kenarları ters sırada işleyerek bulunabilir.

15.1 Kruskal’ın Algoritması

Kruskal’ın Algoritması’nda başlangıçtaki kapsayan ağaçta sadece çizgenin düğümleri bulunur ve herhangi bir kenar içermemektedir. Sonrasında algoritma kenarlara ağırlıklarına göre bakar ve eğer kenar döngü oluşturmuyorsa kenarı kapsayan ağaca ekler.

Algoritma, ağacın parçalarını tutar. İlk başta çizgenin her düğümü ayrı bir parçadır. Her seferinde ağaca bir kenar eklendiği zaman iki parça birleşir. Sonunda bütün düğümler aynı parçaya ait olur ve en küçük kapsayan ağaç bulunur.

Örnek

Algoritmanın ilk adımında kenarlar, ağırlıklarına göre küçükten büyüğe doğru sıralanır:

Bundan sonra algoritma listeden geçer ve kenar iki ayrı parçayı bağlıyorsa kenarı ağaca ekler. Başta her düğüm kendisine ait parçadadır. Ağaca ilk eklenen kenar 5–6 kenarıdır; bu kenar ${5}$ ve ${6}$ parçalarını ${5, 6}$ şeklinde birleştirir. Ardından 1–2, 3–6 ve 1–5 kenarları benzer şekilde eklenir.

Bu adımlardan sonra ağaçta iki parça kalmıştır: ${1, 2, 3, 5, 6}$ ve ${4}$. Listedeki sonraki kenar 2–3‘tür, ancak 2 ve 3 düğümleri aynı parçaya ait olduğundan bu kenar ağaca eklenmez. Aynı nedenden dolayı 2–5 kenarı da eklenmez. En sonunda 4–6 kenarı ağaca eklenir ve algoritma tamamlanır. Oluşan en küçük kapsayan ağacın ağırlığı $2 + 3 + 3 + 5 + 7 = 20$ olur.

Bu Neden Çalışır?

Çizgedeki minimum ağırlıklı kenarı eklemediğimizi varsayalım. Bu durumda mevcut kapsayan ağaçtan bir kenarı çıkartıp yerine minimum ağırlıklı kenarı eklediğimizde daha küçük ağırlığa sahip bir kapsayan ağaç elde ederiz. Bu çelişki, en küçük ağırlığa sahip kenarı eklemenin her zaman optimal olduğunu gösterir. Benzer mantık sonraki kenarlar için de geçerlidir; dolayısıyla Kruskal’ın Algoritması her zaman doğru sonucu verir.

İmplementasyon

Kruskal’ın Algoritması’nı koda geçirirken çizgeyi bir kenar listesinde tutmak daha rahat olur. Algoritmanın ilk aşamasında listedeki kenarlar $O(m \log m)$ zamanda sıralanır. Bundan sonra algoritma en küçük kapsayan ağacı şu şekilde oluşturur:

for (...) {
    if (!same(a, b)) unite(a, b);
}

Döngü listedeki bütün kenarlardan geçer ve her seferinde $a$–$b$ kenarını işler. İki fonksiyon gereklidir:

• same(a, b): $a$ ve $b$ düğümlerinin aynı parçaya ait olup olmadığını belirler.
• unite(a, b): $a$ ve $b$ düğümlerini içeren parçaları birleştirir.

same fonksiyonunu bir çizge dolaşım algoritmasıyla $O(n + m)$ zamanda implement etmek mümkündür; ancak bu fonksiyon her kenar için çağrıldığından algoritma yavaş kalır. Union-find yapısı ile her iki fonksiyon da $O(\log n)$ zamanda çalışır ve Kruskal’ın Algoritması, sıralama adımından sonra $O(m \log n)$ zamanda tamamlanır.

15.2 Union-find Yapısı

Union-find yapısı, parçalardan oluşan bir koleksiyonu tutar. Her eleman sadece bir parçaya aittir; yani parçalar ayrıktır. İki temel $O(\log n)$ işlemi vardır:

• unite: İki parçayı birleştirir.
• find: Verilen elemanın bulunduğu parçanın temsilcisini döndürür.

Yapı

Union-find yapısında her parçadaki bir eleman o parçanın temsilcisi (representative) olur ve parçadaki diğer tüm elemanlardan temsilciye bir bağ vardır. Örneğin ${1, 4, 7}$, ${5}$ ve ${2, 3, 6, 8}$ gibi parçalarımız olduğunu düşünelim; bu durumda temsilciler sırasıyla 4, 5 ve 2 olur.

Her elemanın temsilcisi, o elemandan başlayan bağı takip ederek bulunur. Örneğin 6. elemanın temsilcisi 2’dir çünkü $6 \to 3 \to 2$ bağı mevcuttur. İki elemanın temsilcisi aynıysa bu elemanlar aynı parçadadır.

İki parça, parçaların temsilcilerini birbirine bağlayarak birleştirilir. Verimlilik için her zaman küçük olan parçanın temsilcisini büyük olan parçanın temsilcisine bağlarız; eğer iki parça da aynı büyüklükteyse aralarından birini seçeriz. Bu teknikle herhangi bir bağın uzunluğu $O(\log n)$ olur.

İmplementasyon

Union-find yapısı dizilerle implement edilir. link dizisi her elemanın bağdaki sonraki elemanını (eleman temsilciyse kendisini) tutar. size dizisi ise her temsilcinin bulunduğu parçanın büyüklüğünü verir.

Başlangıçta her eleman ayrı bir parçadadır:

for (int i = 1; i <= n; i++) link[i] = i;
for (int i = 1; i <= n; i++) size[i] = 1;

find fonksiyonu herhangi bir $x$ elemanının temsilcisini bulur:

int find(int x) {
    while (x != link[x]) x = link[x];
    return x;
}

same fonksiyonu $a$ ve $b$ düğümlerinin aynı parçaya ait olup olmadığını kontrol eder:

bool same(int a, int b) {
    return find(a) == find(b);
}

unite fonksiyonu ise $a$ ve $b$ elemanlarını içeren parçaları birleştirir. Fonksiyon önce parçaların temsilcilerini bulur, ardından küçük parçayı büyük parçaya bağlar:

void unite(int a, int b) {
    a = find(a);
    b = find(b);
    if (size[a] < size[b]) swap(a, b);
    size[a] += size[b];
    link[b] = a;
}

find fonksiyonu her bağın uzunluğunun $O(\log n)$ olduğu varsayımıyla $O(\log n)$ zamanda çalışır. unite fonksiyonunun küçük parçayı büyük parçaya bağlaması, bağ uzunluğunun $O(\log n)$ sınırını korumasını sağlar.

15.3 Prim’in Algoritması

Prim’in Algoritması, en küçük kapsayan ağacı bulmak için alternatif bir yöntemdir. Algoritma ilk başta çizgeden herhangi bir düğümü ağaca ekler. Sonra her adımda, ağaca yeni bir düğüm ekleyen en kısa kenarı seçer. En sonunda bütün düğümler ağaca eklenir ve en küçük kapsayan ağaç bulunmuş olur.

Prim’in Algoritması Dijkstra’nın Algoritması‘nı anımsatır. Aralarındaki fark şudur: Dijkstra’nın Algoritması her zaman başlangıç düğümünden en kısa mesafede olan kenarı seçerken, Prim’in Algoritması ağaca eklenmiş herhangi bir düğümden çıkan en kısa kenarı seçer.

Örnek

Başlangıç düğümü olarak 1. düğümü seçelim. İlk adımda 3 uzunluğundaki kenar eklenerek 2. düğüm ağaca katılır. Bundan sonra 5 uzunluğunda iki seçenek olduğunda önce 3. düğüm eklenir. İşlem, bütün düğümler ağaca eklenene kadar devam eder. Oluşan en küçük kapsayan ağacın ağırlığı yine $2 + 3 + 3 + 5 + 7 = 20$ olur.

İmplementasyon

Dijkstra’nın Algoritması gibi Prim’in Algoritması da öncelikli kuyruk ile verimli biçimde yazılabilir. Öncelikli kuyruk, tek kenarla eklenebilen bütün düğümleri, kenar ağırlıklarının artan sırasına göre tutar.

Prim’in Algoritması’nın zaman karmaşıklığı $O(n + m \log m)$ olup Dijkstra’nın Algoritması’nın zaman karmaşıklığıyla aynıdır. Pratikte hem Prim’in hem de Kruskal’ın Algoritmaları verimlidir; hangisinin kullanılacağı kişiden kişiye göre değişir. Yine de çoğu olimpiyatçı Kruskal’ın Algoritması’nı tercih eder.

Örneğin 8 düğüm ve 7 kenardan oluşan bir ağaçta yapraklar (leaves), derecesi 1 olan yani tek komşusu bulunan düğümlerdir. Köklü bir ağaçta düğümlerden biri kök seçilir ve diğer tüm düğümler onun altına yerleştirilir. Köklü ağaçta bir düğümün çocukları (children) onun alt komşuları, ebeveyni (parent) ise üst komşusudur. Her düğümün kök hariç tam bir ebeveyni vardır.

Köklü ağacın yapısı özyinelemelidir: her düğüm, kendisini ve tüm torunlarını kapsayan bir alt ağacın kökü gibi davranır.

14.1 Ağaç Dolaşımı

Genel çizge dolaşım algoritmaları ağaçlarda da kullanılabilir. Ancak ağaçlar döngü içermediğinden ve bir düğüme birden fazla yoldan ulaşılamadığından implementasyon genel çizgelere kıyasla çok daha sadedir.

Ağacı dolaşmanın klasik yolu herhangi bir düğümden DFS başlatmaktır:

void dfs(int s, int e) {
    // s düğümü ile bir şeyler yap
    for (auto u : adj[s]) {
        if (u != e) dfs(u, s);
    }
}

Fonksiyon iki parametre alır: mevcut düğüm s ve onun ebeveyni e. Ebeveyn parametresi, aramanın geri dönüp sonsuz döngüye girmesini önler. Arama x düğümünden şöyle başlatılır:

dfs(x, 0);

İlk çağrıda e = 0 verilir çünkü kökün ebeveyni yoktur.

Dinamik Programlama ile Alt Ağaç Hesapları

Ağaç dolaşımı sırasında dinamik programlama kullanarak her düğüm için yararlı bilgiler $O(n)$ zamanda hesaplanabilir; örneğin alt ağacındaki düğüm sayısı ya da bir düğümden yaprağa olan en uzun mesafe.

Her s düğümü için alt ağacındaki toplam düğüm sayısını veren count[s] değeri şöyle hesaplanır:

void dfs(int s, int e) {
    count[s] = 1;
    for (auto u : adj[s]) {
        if (u == e) continue;
        dfs(u, s);
        count[s] += count[u];
    }
}

Alt ağaç, düğümün kendisini ve tüm çocuklarının alt ağaçlarını içerir; dolayısıyla count[s], çocukların count değerlerinin toplamına 1 eklenerek bulunur.

14.2 Çap

Bir ağacın çapı (diameter), ağaçtaki herhangi iki düğüm arasındaki en uzun mesafedir. Aynı uzunlukta birden fazla en uzun yol bulunabilir.

Çapı bulmak için $O(n)$ zamanda çalışan iki farklı algoritma vardır.

1. Algoritma: Dinamik Programlama

Ağacı köklendirip her alt ağaç için çapı ayrı ayrı hesaplayan bir yaklaşımdır. Köklü ağaçtaki her yolun bir en yüksek noktası (tepesi) vardır; yani yolda geçilen en üstteki düğüm. Bu gözlemden yola çıkarak her düğüm için iki değer hesaplanır:

• $\text{toLeaf}(x)$: $x$ düğümünden herhangi bir yaprağa olan en uzun mesafe.
• $\text{maxLength}(x)$: tepe noktası $x$ olan en uzun yolun uzunluğu.

Örneğin 1. düğümün kök olduğu bir ağaçta $\text{toLeaf}(1) = 2$ ise ($1 \to 2 \to 6$ yoluyla) ve $\text{maxLength}(1) = 4$ ise ($6 \to 2 \to 1 \to 4 \to 7$ yoluyla) ağacın çapı $\text{maxLength}(\text{kök})$’e eşittir.

Hesaplama adımları:

• $\text{toLeaf}(x)$: $x$’in çocukları arasında $\text{toLeaf}(c)$ değeri en büyük olan $c$ seçilir ve $\text{toLeaf}(x) = \text{toLeaf}(c) + 1$ olur.
• $\text{maxLength}(x)$: En büyük $\text{toLeaf}$ değerine sahip iki farklı $a, b$ çocuğu seçilir; $\text{maxLength}(x) = \text{toLeaf}(a) + \text{toLeaf}(b) + 2$ olur.

2. Algoritma: İki DFS

Çapı bulmanın daha şık bir yolu iki DFS çalıştırmaktır:

1. Ağaçta rastgele bir $a$ düğümü seç.
2. $a$’dan en uzaktaki $b$ düğümünü bul (BFS veya DFS ile).
3. $b$’den en uzaktaki $c$ düğümünü bul.
4. $b$ ile $c$ arasındaki mesafe ağacın çapıdır.

Bu yöntemin neden doğru çalıştığını anlamak için ağacı çap yatay olacak şekilde düşünmek yeterlidir. Rastgele seçilen $a$ düğümü çapın dışında olsa bile, $a$’dan en uzak düğüm olan $b$ her zaman çap yolunun bir ucu olur. Çünkü $b$, çap uçlarından en az $a$’nın çapla kesişim noktasına olan mesafesi kadar uzakta olmak zorundadır ve bu da onu daima çapın bir ucuna karşılık getirir.

14.3 Bütün En Uzun Yollar

Her düğüm için o düğümden başlayan en uzun yolun uzunluğunu $\text{maxLength}(x)$ olarak hesaplamak istiyoruz. Bu, çap probleminin genelleştirilmiş halidir; sonuçların en büyüğü ağacın çapına eşit olur.

Örneğin aşağıdaki tablo 6 düğümlü bir ağaç için sonuçları gösterir:

Problem $O(n)$ zamanda iki aşamada çözülür.

Aşama 1: Her $x$ düğümü için çocuklarından geçen en uzun yol dinamik programlamayla hesaplanır (Bölüm 14.2’deki yaklaşımla aynıdır).

Aşama 2: Her $x$ düğümü için ebeveyninden $p$’den geçen en uzun yol bulunur. Burada dikkat edilmesi gereken bir incelik vardır: $p$’den geçen en uzun yol bazen $x$ üzerinden geçebilir. Bu durumda $x$’e ait olmayan yönde bir çözüm gerekir.

Bu sorunu çözmek için her $x$ düğümüne ait iki maksimum değer saklanır:

• $\text{maxLength}_1(x)$: $x$ düğümünden geçen en uzun yolun uzunluğu.
• $\text{maxLength}_2(x)$: $x$ düğümünden farklı bir yönde geçen ikinci en uzun yolun uzunluğu.

Son adımda: eğer $p$’nin $\text{maxLength}_1$ değerini sağlayan yol $x$ üzerinden geçiyorsa cevap $\text{maxLength}_2(p) + 1$, geçmiyorsa $\text{maxLength}_1(p) + 1$ olur.

14.4 İkili Ağaç

İkili ağaç (binary tree), her düğümün sol ve sağ olmak üzere en fazla iki çocuğu bulunan köklü bir ağaçtır. Bir çocuk olmayabilir; dolayısıyla her düğümün 0, 1 veya 2 çocuğu olabilir.

Dolaşım Sıraları

İkili ağacın düğümleri dolaşım biçimine göre üç farklı sırayla listelenebilir:

• Önce kök (pre-order): Kök → Sol alt ağaç → Sağ alt ağaç
• Kök ortada (in-order): Sol alt ağaç → Kök → Sağ alt ağaç
• Kök sonda (post-order): Sol alt ağaç → Sağ alt ağaç → Kök

Örneğin aşağıdaki ikili ağaç için:

      1
     / \
    2   3
   / \   \
  4   5   7
     /
    6

Ağacı Yeniden Oluşturmak

İki dolaşım sırasından ağacın tam yapısını çıkarmak mümkündür; ancak hangi iki sıranın yeterli olduğu önemlidir:

• Önce kök + Kök ortada → Ağaç yapısı benzersiz biçimde belirlenir.
• Kök sonda + Kök ortada → Ağaç yapısı benzersiz biçimde belirlenir.
• Önce kök + Kök sonda → Ağaç yapısı benzersiz belirlenemez; birden fazla ağaç bu iki sırayla uyuşabilir.

Örneğin önce kök sırası $[1, 2]$ ve kök sonda sırası $[2, 1]$ olan iki farklı ağaç yapısı mevcuttur: birinde 2, kökün sol çocuğu; diğerinde ise sağ çocuğudur.

13.1 Bellman–Ford Algoritması

Bellman–Ford algoritması¹, başlangıç düğümünden çizgedeki tüm düğümlere en kısa mesafeyi bulur. Negatif döngü içermeyen her türlü çizgede çalışır; üstelik çizgede negatif döngü varsa bunu tespit edebilir.

Algoritma, başlangıç düğümüne 0, diğer tüm düğümlere sonsuz mesafe atayarak başlar. Her turda tüm kenarlar incelenerek mesafeler kısaltılmaya çalışılır. Hiçbir mesafe artık kısalımıyorsa algoritma durur.

Örnek

Aşağıdaki 5 düğümlü ağırlıklı çizgede 1. düğümden başlayan Bellman–Ford adımları:

Başlangıç: Mesafeler $[0, \infty, \infty, \infty, \infty]$

1. tur — 1. düğümden çıkan tüm kenarlar mesafeleri azaltır:

2. tur — $2 \to 5$ ve $3 \to 4$ kenarları devreye girer:

3. tur — Son bir güncelleme daha:

Artık hiçbir kenar mesafeyi azaltamaz; başlangıç düğümünden tüm düğümlere en kısa mesafeler bulunmuştur. Örneğin 1. düğümden 5. düğüme en kısa mesafe 3’tür.

İmplementasyon

// distance[i]: x düğümünden i düğümüne en kısa mesafe
// edges: (a, b, w) formatında kenar listesi

for (int i = 1; i <= n; i++) distance[i] = INF;
distance[x] = 0;

for (int i = 1; i <= n - 1; i++) {
    for (auto e : edges) {
        int a, b, w;
        tie(a, b, w) = e;
        distance[b] = min(distance[b], distance[a] + w);
    }
}

Algoritma $n - 1$ tur çalışır; her turda $m$ kenarı işler. Zaman karmaşıklığı $O(nm)$’dir. En kısa her yol en fazla $n - 1$ kenar içerdiğinden $n - 1$ tur sonunda tüm mesafeler kesinleşir. Pratikte son mesafeler çoğu zaman $n - 1$ turdan önce bulunur; bir tur boyunca hiçbir mesafe değişmezse algoritma erken sonlandırılabilir.

Negatif Döngüler

Bellman–Ford algoritması çizgede negatif döngü bulunup bulunmadığını da kontrol eder. Örneğin $2 \to 3 \to 4 \to 2$ döngüsünün toplam ağırlığı $-4$ ise bu döngüyü içeren yolları sınırsız kısaltmak mümkün olur; bu durumda “en kısa yol” tanımsızlaşır.

Negatif döngüyü tespit etmek için $n$. bir tur daha koşulur. Bu turda herhangi bir mesafe hâlâ azalıyorsa çizgede negatif döngü vardır. Bu yöntem, başlangıç düğümünden bağımsız olarak çizgenin herhangi bir yerindeki negatif döngüyü yakalar.

SPFA Algoritması

SPFA (“Shortest Path Faster Algorithm”), Bellman–Ford’un optimize edilmiş bir varyantıdır. Her turda tüm kenarları değil, yalnızca mesafesi azalan düğümlere bağlı kenarları inceler. Bunun için mesafesi azalabilen düğümleri bir kuyrukta tutar. Ortalama durumda Bellman–Ford’dan hızlıdır; ancak en kötü durumda zaman karmaşıklığı yine $O(nm)$’dir.

13.2 Dijkstra’nın Algoritması

Dijkstra’nın algoritması², Bellman–Ford gibi başlangıç düğümünden tüm düğümlere en kısa mesafeleri bulur; fakat çok daha verimlidir ve daha büyük çizgelerde kullanılabilir. Tek koşul: çizgede negatif ağırlıklı kenar bulunmamalıdır.

Bellman–Ford’dan farklı olarak Dijkstra her kenarı yalnızca bir kez işler. Bu verimliliği, negatif ağırlıklı kenar bulunmaması garantisiyle sağlanır.

Örnek

1. düğümden başlayarak 5 düğümlü ağırlıklı çizgede Dijkstra’nın adımları:

Başlangıç: $[0,\ \infty,\ \infty,\ \infty,\ \infty]$

Adım 1 — 0 mesafeli 1. düğüm seçilir; komşularının mesafeleri güncellenir:

Adım 2 — 1 mesafeli 5. düğüm seçilir; 4. düğümün mesafesi 9’dan 3’e iner:

Adım 3 — 3 mesafeli 4. düğüm seçilir; 3. düğümün mesafesi 9 olur:

Dijkstra’nın önemli özelliği: bir düğüm seçildiğinde onun mesafesi artık değişmez. Örneğin bu aşamada 1, 5 ve 4. düğümlerin mesafeleri kesinleşmiştir.

Son durum:

Negatif Kenarlar

Dijkstra, negatif kenarlarda hatalı sonuç üretebilir. Örneğin $-5$ ağırlıklı bir kenar varsa algoritma bu kenarın öncesindeki yüksek maliyeti geç fark eder ve yanlış en kısa yolu seçebilir. Bu durumda Bellman–Ford kullanılmalıdır.

İmplementasyon

Verimli Dijkstra implementasyonu için işlenmemiş düğümler arasından mesafesi en küçük olanı hızla bulmak gerekir. Bunun için öncelikli kuyruk (priority queue) kullanılır.

C++’ın varsayılan öncelikli kuyruğu maksimum elemana öncelik verdiğinden, mesafeleri negatif tutarak minimum elemanın başa gelmesi sağlanır:

// adj[a] = {b, w}: a'dan b'ye w ağırlığında kenar

priority_queue<pair<int,int>> q;
bool processed[N];

for (int i = 1; i <= n; i++) distance[i] = INF;
distance[x] = 0;
q.push({0, x});

while (!q.empty()) {
    int a = q.top().second; q.pop();
    if (processed[a]) continue;
    processed[a] = true;
    for (auto u : adj[a]) {
        int b = u.first, w = u.second;
        if (distance[a] + w < distance[b]) {
            distance[b] = distance[a] + w;
            q.push({-distance[b], b});
        }
    }
}

Öncelikli kuyrukta aynı düğüme ait birden fazla eleman bulunabilir; ancak yalnızca en kısa mesafeli olan işlenir (processed kontrolü sayesinde). Zaman karmaşıklığı $O(n + m \log m)$’dir: tüm düğümler işlenir ve her kenar için kuyruğa en fazla bir eleman eklenir³.

13.3 Floyd–Warshall Algoritması

Floyd–Warshall algoritması⁴, tek bir kaynaktan değil, tüm düğüm çiftleri arasındaki en kısa mesafeleri tek bir koşuda bulur. Diğer iki algoritmadan farklı olarak hem negatif kenarlarda hem de negatif döngü tespitinde kullanılabilir.

Algoritma, iki boyutlu bir mesafe matrisi tutar. Başlangıçta matris yalnızca doğrudan kenarlarla doldurulur. Sonra her düğüm sırayla ara düğüm olarak denenerek mevcut mesafeler kısaltılmaya çalışılır.

Örnek

5 düğümlü ağırlıklı çizge için başlangıç matrisi (∞ = sonsuz):

1. tur (ara düğüm: 1) — 2 ile 4 arasında ve 2 ile 5 arasında yeni yollar keşfedilir.

2. tur (ara düğüm: 2) — 1–3 ve 3–5 arasında yeni yollar bulunur.

3. tur (ara düğüm: 3) — 2–4 arasındaki mesafe kısalır.

Tüm turlar bittikten sonra matris her iki düğüm arasındaki minimum mesafeleri tutar:

Örneğin 2 ile 4. düğüm arasındaki en kısa mesafe 8 olup $2 \to 3 \to 1 \to 5 \to 4$ yoluna karşılık gelir.

İmplementasyon

Floyd–Warshall’ın en büyük avantajı son derece sade bir koda sahip olmasıdır:

// Başlatma
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (i == j) distance[i][j] = 0;
        else if (adj[i][j]) distance[i][j] = adj[i][j];
        else distance[i][j] = INF;
    }
}

// En kısa mesafeleri bulma
for (int k = 1; k <= n; k++) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            distance[i][j] = min(distance[i][j],
                                 distance[i][k] + distance[k][j]);
        }
    }
}

Üç iç içe döngü nedeniyle zaman karmaşıklığı $O(n^3)$’tür. Kodu sade olduğundan, tek bir en kısa yol bulmak gerekse bile çizge yeterince küçükse kullanılabilir.

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

12.1 Derinlik Öncelikli Arama (DFS)

Derinlik öncelikli arama (Depth-First Search — DFS), sezgisel bir çizge dolaşma tekniğidir. Algoritma başlangıç düğümünden hareket ederek çizgenin kenarlarını kullanır ve ulaşılabilir tüm düğümleri ziyaret eder. DFS, yeni bir düğüm buldukça tek bir yolu izlemeye devam eder; çıkmaza girdiğinde ise geri dönerek çizgenin diğer bölgelerini keşfeder. Her düğüm yalnızca bir kez ziyaret edilip işlenir.

Algoritmanın zaman karmaşıklığı $O(n + m)$’dir; burada $n$ düğüm sayısı, $m$ ise kenar sayısıdır. Bu, algoritmanın her düğümü ve kenarı tam bir kez işlemesinden kaynaklanır.

Örnek

Aşağıdaki beş düğümlü çizgede DFS’in 1. düğümden nasıl ilerlediğini izleyelim:

1 — 2
|   |
4   3
 \ /
  5

DFS 1. düğümden başlar ve önce 2. düğüme geçer. Oradan 3, ardından 5. düğüm ziyaret edilir. 5. düğümün komşuları olan 2 ve 3 zaten ziyaret edildiği için geri dönülür. 3 ve 2. düğümlerin tüm kenarları da işlendiğinden 1. düğüme dönülür ve oradan 4. düğüme gidilir. Tüm düğümler ziyaret edildiğinde arama sona erer.

Ziyaret sırası: $1 \to 2 \to 3 \to 5 \to 4$

İmplementasyon

DFS, özyineleme (recursion) ile kolayca kodlanabilir. dfs fonksiyonu belirtilen düğümden aramaya başlar. Çizge komşuluk listelerinde, ziyaret edilen düğümler ise visited dizisinde tutulur:

vector<int> adj[N];
bool visited[N];

void dfs(int s) {
    if (visited[s]) return;
    visited[s] = true;
    // s düğümüyle bir şeyler yap
    for (auto u : adj[s]) {
        dfs(u);
    }
}

Başta visited dizisinin tüm elemanları false‘tur. Arama s düğümüne geldiğinde visited[s] değeri true olarak işaretlenir ve o düğüm bir daha işlenmez.

12.2 Genişlik Öncelikli Arama (BFS)

Genişlik öncelikli arama (Breadth-First Search — BFS), düğümleri başlangıç düğümüne olan mesafeye göre artan sırada ziyaret eder. Bu özelliği sayesinde BFS, tüm düğümlerin başlangıç düğümüne olan en kısa mesafelerini hesaplamak için doğal bir araçtır. Bununla birlikte DFS’e kıyasla koda geçirilmesi biraz daha karmaşıktır.

BFS düğümleri katman katman (level by level) dolaşır: önce başlangıç düğümüne 1 uzaklıktaki düğümler, ardından 2 uzaklıktakiler ve böyle devam eder. Tüm düğümler ziyaret edilene kadar sürer. Zaman karmaşıklığı DFS ile aynıdır: $O(n + m)$.

Örnek

Altı düğümlü çizgede BFS’in 1. düğümden nasıl ilerlediğini izleyelim:

1 — 2 — 3
|       |
4   5 — 6

İlk adımda 1’den tek bir kenarla ulaşılan 2 ve 4 ziyaret edilir. Sonra 2’nin komşusu 3 ve bağlantılı yoldan 5 ziyaret edilir. En sonda 6 ziyaret edilir.

Hesaplanan mesafeler:

İmplementasyon

BFS bir kuyruk (queue) veri yapısıyla koda dökülür. Her adımda kuyruğun başındaki düğüm işlenir; yeni keşfedilen düğümler kuyruğun sonuna eklenir. Böylece düğümler her zaman mesafe sırasına göre işlenir.

queue<int> q;
bool visited[N];
int distance[N];

// x: başlangıç düğümü
visited[x] = true;
distance[x] = 0;
q.push(x);

while (!q.empty()) {
    int s = q.front(); q.pop();
    // s düğümüyle bir şeyler yap
    for (auto u : adj[s]) {
        if (visited[u]) continue;
        visited[u] = true;
        distance[u] = distance[s] + 1;
        q.push(u);
    }
}

visited dizisi ziyaret edilen düğümleri, distance dizisi ise başlangıç düğümünden her düğüme olan en kısa mesafeyi tutar.

12.3 Uygulamalar

Çizge dolaşma algoritmaları, çizgenin çeşitli özelliklerini tespit etmek için kullanılabilir. Genellikle DFS de BFS de işe yarar; ancak DFS özyinelemeli yapısıyla daha sade yazıldığından pratikte daha sık tercih edilir. Aşağıdaki uygulamalar çizgenin yönsüz olduğunu varsayar.

Bağlılık Kontrolü

Bir çizge, her iki düğümü arasında yol varsa bağlıdır. Bağlılığı kontrol etmek için herhangi bir düğümden dolaşma başlatılır ve tüm düğümlerin ziyaret edilip edilmediğine bakılır. Ziyaret edilmemiş düğüm varsa çizge bağlı değildir.

Çizgenin tüm bağlı parçalarını (components) bulmak için ziyaret edilmemiş her düğümden yeni bir dolaşma başlatmak yeterlidir:

for (int i = 1; i <= n; i++) {
    if (!visited[i]) dfs(i); // yeni bir parça başlıyor
}

Döngü Bulmak

Dolaşma sırasında daha önce ziyaret edilmiş bir komşuya ulaşılırsa — bir önceki düğüm hariç — çizgede döngü (cycle) vardır.

Örneğin 2. düğümden 5. düğüme geçerken 5’in komşusu olan 3’ün zaten ziyaret edildiği görülürse $3 \to 2 \to 5 \to 3$ döngüsü tespit edilmiş olur.

Alternatif bir yöntem: her parçanın düğüm ve kenar sayısını karşılaştırmak. Parça $c$ düğüm içeriyorsa ve döngüsüzse tam $c - 1$ kenar içerir (yani bir ağaçtır). $c$ veya daha fazla kenar içeriyorsa o parça en az bir döngü barındırıyordur.

İki Parçalılık Kontrolü

Komşu düğümlerin asla aynı renge sahip olmayacağı şekilde yalnızca iki renkle boyanabilen çizge iki parçalıdır (bipartite). Bunu çizge dolaşmayla kontrol etmek oldukça kolaydır.

Başlangıç düğümü maviye boyanır, tüm komşuları kırmızıya, ardından o komşuların komşuları tekrar maviye boyama şeklinde alternatif renkler atanır. Eğer dolaşma sırasında iki komşu düğüm aynı renge boyanmışsa çizge iki parçalı değildir. Böyle bir çelişki oluşmazsa çizge iki parçalıdır ve elde edilen boyama geçerli bir çözümdür.

Örneğin tek sayıda kenara sahip bir döngü içeren çizgede bu boyama mutlaka bir çelişkiyle sonuçlanır. Başlangıç düğümüne hangi rengin atandığının önemi yoktur; seçilen renk otomatik olarak diğer tüm düğümlerin rengini belirler.

Genel durumda bir çizgeyi $k$ renkle boyamak ise çok daha zordur. $k = 3$ için dahi bilinen verimli bir algoritma yoktur; bu problem NP-hard‘dır.

11.1 Çizge Terminolojisi

Bir çizge (graph), düğümlerden (nodes) ve kenarlardan (edges) oluşur. Bu yazıda $n$ çizgedeki toplam düğüm sayısını, $m$ ise toplam kenar sayısını belirtecektir. Düğümler $1, 2, \ldots, n$ tamsayılarıyla numaralandırılır.

Yol ve Döngü

Yol (path), $a$ düğümünden $b$ düğümüne kenarlar kullanılarak ulaşılmasını sağlar. Yolun uzunluğu, yolda geçilen kenar sayısına eşittir. Örneğin $1 \to 3 \to 4 \to 5$ yolu, 1. düğümden 5. düğüme 3 uzunluğunda bir yoldur.

Başlangıç ve son düğümün aynı olduğu yola döngü (cycle) denir. Bir yolda her düğüm en fazla bir kez geçiyorsa bu yol basittir (simple).

Bağlılık

Her iki düğümü arasında bir yol bulunan çizge bağlıdır (connected). Bir çizgenin bağlı alt gruplarına parça (component) denir. Örneğin ${1,2,3}$, ${4,5,6,7}$ ve ${8}$ olmak üzere üç parçalı bir çizge bağlı değildir.

Bir çizge bağlıysa ve $n$ düğüm ile $n-1$ kenardan oluşuyorsa bu çizge bir ağaçtır (tree). Ağaçta her iki düğüm arasında tam olarak bir yol vardır.

Kenar Yönleri

Kenarların tek yönlü olduğu çizge yönlüdür (directed). Yönlü bir çizgede $3 \to 1 \to 2 \to 5$ yolu olabilirken $5$’ten $3$’e giden herhangi bir yol olmayabilir.

Kenar Ağırlıkları

Ağırlıklı (weighted) bir çizgede her kenarın bir ağırlığı vardır; bu ağırlık genellikle uzunluk olarak yorumlanır. Ağırlıklı bir çizgedeki yolun uzunluğu, yoldaki kenarların ağırlıklarının toplamıdır. Örneğin $1 \to 2 \to 5$ yolunun uzunluğu 12, $1 \to 3 \to 4 \to 5$ yolunun uzunluğu 11 olabilir; burada ikinci yol daha kısadır.

Komşular ve Dereceler

İki düğüm arasında kenar varsa bunlar komşu (neighbor) düğümlerdir. Bir düğümün derecesi (degree), komşu sayısına eşittir.

$m$ kenarlı bir çizgenin toplam derece sayısı her zaman $2m$’dir; çünkü her kenar iki düğümün derecesini birer artırır. Bu nedenle derece toplamı daima çifttir.

Yönlü çizgelerde bir düğümün iç derecesi (indegree) o düğüme gelen kenar sayısını, dış derecesi (outdegree) ise o düğümden çıkan kenar sayısını verir.

Her düğümün derecesi $d$ ise çizge sıradan (regular), her düğüm birbirine bağlıysa (derece $n-1$) çizge tam (complete) olarak adlandırılır.

Boyamalar

Çizgeyi boyarken komşu düğümlerin farklı renk almasına dikkat edilir. Yalnızca iki renkle boyanabilen çizge iki parçalıdır (bipartite). Bir çizgenin iki parçalı olabilmesi için tek sayıda kenarlı herhangi bir döngü içermemesi gerekir.

Örneğin altı düğümlü bir çizge iki parçalıysa düğümler iki gruba ayrılıp her kenar gruplar arasında geçer; iki renkle boyanabilir. Ama tek sayıda kenarlı bir döngü içeriyorsa boyama mümkün olmaz.

Genel durumda bir çizgenin $k$ renkle boyanıp boyanamayacağını bulmak zordur. $k = 3$ için dahi bilinen verimli bir algoritma yoktur — bu problem NP-hard‘dır.

Basitlik

Aynı düğümde başlayıp biten kenar (öz-döngü) veya iki düğüm arasında birden fazla kenar içeren çizge basit değildir (not simple). Genellikle çizgelerin basit olduğu kabul edilir.

11.2 Çizge Gösterimi

Algoritmalarda çizgeleri göstermenin birkaç yaygın yolu vardır. Veri yapısının seçimi çizgenin büyüklüğüne ve algoritmanın çizgeyi işleme biçimine göre değişir.

Komşuluk Listesi Gösterimi

Komşuluk listesi (adjacency list) gösteriminde her $x$ düğümüne bir liste atanır; bu liste $x$’ten çıkan kenarların ulaştığı düğümleri içerir. Komşuluk listeleri çizgeleri göstermenin en popüler yoludur ve çoğu algoritma bu yöntemle verimli biçimde kodlanabilir.

Komşuluk listesini oluşturmanın pratik yolu vektörlerden oluşan bir dizi kullanmaktır:

vector<int> adj[N];

Örneğin aşağıdaki çizge için:

adj[1].push_back(2);
adj[2].push_back(3);
adj[2].push_back(4);
adj[3].push_back(4);
adj[4].push_back(1);

Yönsüz (undirected) çizgelerde her kenar her iki yöne de eklenir. Ağırlıklı bir çizge için yapı şöyle güncellenir:

vector<pair<int,int>> adj[N];

Bu durumda $a$ düğümünden $b$ düğümüne $w$ ağırlığında kenar varsa $a$’nın listesi $(b, w)$ çiftini içerir:

adj[1].push_back({2, 5});
adj[2].push_back({3, 7});
adj[2].push_back({4, 6});
adj[3].push_back({4, 5});
adj[4].push_back({1, 2});

Komşuluk listesinin en büyük avantajı, bir düğümden ulaşılabilecek düğümlerin hızlıca dolaşılabilmesidir:

for (auto u : adj[s]) {
    // u düğümünü işle
}

Komşuluk Matrisi Gösterimi

Komşuluk matrisi (adjacency matrix) gösterimi, çizgedeki kenarları iki boyutlu bir dizide tutar ve iki düğüm arasında kenar olup olmadığını $O(1)$ zamanda sorgular:

int adj[N][N];

adj[a][b] = 1 ise $a$’dan $b$’ye kenar vardır, adj[a][b] = 0 ise yoktur. Ağırlıklı çizgelerde kenar ağırlığı da bu matriste tutulabilir.

Dezavantajı, $n^2$ elemanlık bir dizi gerektirmesidir. Büyük çizgeler için bellek açısından pratik değildir; özellikle matrisin büyük bölümü sıfırdan oluştuğunda (seyrek çizgeler).

Kenar Listesi Gösterimi

Kenar listesi (edge list) gösterimi, çizgenin tüm kenarlarını rastgele bir sırada bir vektörde tutar. Algoritma tüm kenarları işliyorsa ve belirli bir düğümden başlayan kenarları bulmaya gerek yoksa bu gösterim uygundur.

vector<pair<int,int>> edges;

Her $(a, b)$ çifti, $a$ düğümünden $b$ düğümüne bir kenar olduğunu gösterir:

edges.push_back({1, 2});
edges.push_back({2, 3});
edges.push_back({2, 4});
edges.push_back({3, 4});
edges.push_back({4, 1});

Ağırlıklı çizgeler için yapı üçlü demet olarak genişletilir:

vector<tuple<int,int,int>> edges;

Her $(a, b, w)$ demeti, $a$’dan $b$’ye $w$ ağırlığında kenar olduğunu belirtir¹:

edges.push_back({1, 2, 5});
edges.push_back({2, 3, 7});
edges.push_back({2, 4, 6});
edges.push_back({3, 4, 5});
edges.push_back({4, 1, 2});

Gösterimler Arasında Karşılaştırma

Seyrek çizgelerde ($m \ll n^2$) komşuluk listesi tercih edilir. Yoğun çizgelerde ($m \approx n^2$) komşuluk matrisi pratik olabilir. Bellman-Ford gibi tüm kenarları tek tek işleyen algoritmalar için kenar listesi doğal bir seçimdir.

• sumq(a, b): $[a, b]$ aralığındaki sayıların toplamını bul
• minq(a, b): $[a, b]$ aralığındaki minimum sayıyı bul
• maxq(a, b): $[a, b]$ aralığındaki maksimum sayıyı bul

Örneğin [1, 3, 8, 4, 6, 1, 3, 4] dizisinde $[3,6]$ aralığı için sumq(3,6) = 14, minq(3,6) = 1, maxq(3,6) = 6 olur.

En basit yaklaşım aralık içindeki tüm elemanlara tek tek bakmaktır; bu $O(n)$ sürer. $q$ sorgu için toplam $O(nq)$ zaman gerekir. Hem $n$ hem de $q$ büyük olduğunda bu yavaş kalır. Neyse ki aralık sorgularını çok daha verimli yapmanın yolları vardır.

9.1 Statik Dizi Sorguları

Dizinin statik olduğu (sorgular sırasında değerlerin değişmediği) duruma ilk bakacağız. Bu durumda sorguları sabit zamanda yanıtlayan bir veri yapısı oluşturmak yeterlidir.

Toplam Sorguları

Statik bir dizideki toplam sorgularını prefix toplam dizisi ile kolayca çözebiliriz. Prefix toplam dizisindeki $k$. konum, orijinal dizinin $[0, k]$ aralığının toplamına eşittir; yani sumq(0, k) değerini tutar. Bu dizi $O(n)$ zamanda oluşturulabilir.

Örneğin [1, 3, 4, 8, 6, 1, 4, 2] dizisine karşılık gelen prefix toplam dizisi:

1  4  8  16  22  23  27  29
0  1  2   3   4   5   6   7

Herhangi bir sumq(a, b) değerini $O(1)$ zamanda şu formülle bulabiliriz:

$\text{sumq}(0, -1) = 0$ tanımlaması sayesinde formül $a = 0$ için de geçerlidir. Örneğin:

Bu fikir daha fazla boyuta da genelleşir. İki boyutlu bir prefix toplam dizisi oluşturularak herhangi bir dikdörtgen alt dizi toplamı $O(1)$ zamanda hesaplanabilir. Gri alt dizinin toplamı, $S(X)$’in sol üst köşeden $X$ pozisyonuna gelen dikdörtgen alt dizi toplamı olduğu varsayılarak şu formülle bulunur:

Minimum Sorgular

Minimum sorgular, toplam sorgularına göre daha zordur. Yine de $O(n \log n)$’lik bir ön işleme ile minimum sorguları $O(1)$ zamanda yanıtlanabilir¹. Minimum ve maksimum sorgular benzer şekilde ele alındığından yalnızca minimuma bakacağız.

Fikir: Uzunluğu ikinin kuvveti olan tüm minq(a, b) değerleri önceden hesaplanır. Örneğin [1, 3, 4, 8, 6, 1, 4, 2] dizisi için bu değerler uzunluk 1, 2 ve 4’lük aralıklar için aşağıdaki gibidir:

Toplam $O(n \log n)$ değer, aşağıdaki özyinelemeli formülle hesaplanır ($w = (b - a + 1)/2$):

Sorgu anında $b - a + 1$ değerini geçmeyen en büyük ikinin kuvveti $k$ alınır ve:

formülü $O(1)$ zamanda sonucu verir. Örneğin $[1, 6]$ aralığında uzunluk 6 için $k = 4$ seçilir; $[1,4]$ ve $[3,6]$ aralıklarının birleşimi olarak $\text{minq}(1,6) = \min(3, 1) = 1$ bulunur.

9.2 İkili İndisli Ağaç (Binary Indexed Tree)

İkili indisli ağaç ya da Fenwick ağacı², prefix toplam dizisinin dinamik versiyonu olarak düşünülebilir. $O(\log n)$ zamanda iki operasyonu destekler: aralık toplamı sorgusu ve tek eleman güncellemesi. Prefix toplam dizisinden farkı, her güncellemeden sonra diziyi baştan oluşturmak yerine yalnızca ilgili konumları güncellemesidir.

Yapı

Bu bölümde diziler 1’den indislenir. $p(k)$, $k$’yı tam bölen en büyük 2’nin kuvveti olsun. İkili indisli ağaç tree dizisinde şu şekilde tutulur:

Yani her $k$ konumu, uzunluğu $p(k)$ olan ve $k$’da biten aralığın toplamını tutar. Örneğin $p(6) = 2$ olduğundan tree[6], sumq(5, 6) değerini saklar.

[1, 3, 4, 8, 6, 1, 4, 2] dizisine karşılık gelen ikili indisli ağaç:

1  4  4  16  6  7  4  29
1  2  3   4  5  6  7   8

$[1, k]$ aralığı her zaman ağaçta toplamları tutulan $O(\log n)$ alt aralığa bölünebildiğinden sumq(1, k) değeri $O(\log n)$ zamanda hesaplanabilir. Örneğin:

$a > 1$ durumunda ise:

İmplementasyon

İkili indisli ağaç, bit operasyonları kullanılarak verimli biçimde kodlanabilir. $p(k)$ değeri şöyle hesaplanır:

sumq(1, k) değerini hesaplayan fonksiyon:

int sum(int k) {
    int s = 0;
    while (k >= 1) {
        s += tree[k];
        k -= k & -k;
    }
    return s;
}

$k$. pozisyondaki elemanı $x$ kadar artıran fonksiyon:

void add(int k, int x) {
    while (k <= n) {
        tree[k] += x;
        k += k & -k;
    }
}

Her iki fonksiyon da $O(\log n)$ zamanda çalışır; her adımda $O(\log n)$ farklı konuma erişilir ve her hareket $O(1)$ zaman alır.

9.3 Segment Ağacı

Segment ağacı³ iki operasyonu destekleyen genel amaçlı bir veri yapısıdır: aralık sorgusu ve tek eleman güncellemesi. İkili indisli ağaca kıyasla daha geneldir; yalnızca toplam değil minimum, maksimum, EBOB, bit operasyonları (AND, OR, XOR) gibi pek çok sorguyu da $O(\log n)$ zamanda destekler. Bununla birlikte daha fazla bellek kullanır ve implementasyonu biraz daha karmaşıktır⁴.

Yapı

Segment ağacı bir ikili ağaçtır; en alt seviyedeki yapraklar dizi elemanlarına, iç düğümler ise aralık sorgularına gereken bilgilere karşılık gelir. Dizinin boyutunun ikinin kuvveti olduğu ve sıfır tabanlı indis kullanıldığı varsayılır; gerekirse fazladan eleman eklenebilir.

Toplam sorgularını destekleyen [5, 8, 6, 3, 2, 7, 2, 6] dizisine karşılık gelen segment ağacı:

           39
       22      17
    13    9   9   8
   5 8  6 3  2 7 2 6

Her iç düğüm, kendisine karşılık gelen aralığın elemanlarının toplamını tutar ve bu değer sol ile sağ çocuklarının toplamına eşittir.

Herhangi bir $[a, b]$ aralığı, değerleri ağaç düğümlerinde bulunan $O(\log n)$ alt aralığa bölünebilir. Örneğin $[2, 7]$ aralığı için sumq(2,7) = 9 + 17 = 26. Her seviyeden en fazla iki düğüm kullanıldığından toplam düğüm sayısı $O(\log n)$ olur.

Bir dizi güncellemesinden sonra değişen düğümdeki yapraktan köke giden yoldaki tüm iç düğümler güncellenir; bu yol $O(\log n)$ düğüm içerir.

İmplementasyon

Segment ağacı, $n$ elemanlı bir dizi için $2n$ elemanlı bir dizi içinde tutulur. tree[1] köke, tree[2] ve tree[3] köke bağlı çocuklara karşılık gelir. tree[n]‘den tree[2n-1]‘e kadar olan değerler yaprak düğümlerdir.

39 22 17 13  9  9  8  5  8  6  3  2  7  2  6
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Bu gösterimde tree[k]‘nin ebeveyni tree[⌊k/2⌋], çocukları tree[2k] ve tree[2k+1] olur.

sumq(a, b) değerini hesaplayan fonksiyon:

int sum(int a, int b) {
    a += n; b += n;
    int s = 0;
    while (a <= b) {
        if (a % 2 == 1) s += tree[a++];
        if (b % 2 == 0) s += tree[b--];
        a /= 2; b /= 2;
    }
    return s;
}

$k$. pozisyondaki elemanı $x$ kadar artıran fonksiyon:

void add(int k, int x) {
    k += n;
    tree[k] += x;
    for (k /= 2; k >= 1; k /= 2) {
        tree[k] = tree[2*k] + tree[2*k+1];
    }
}

Her iki fonksiyon da $O(\log n)$ zamanda çalışır.

Diğer Sorgular

Segment ağaçları, bir aralığı iki parçaya bölmenin mümkün olduğu tüm sorgular için kullanılabilir: minimum/maksimum, EBOB, AND/OR/XOR gibi bit operasyonları. Örneğin minimum sorgularını destekleyen ağaçta her düğüm, ilgili aralığın minimumunu tutar.

Segment ağacının ikili ağaç yapısı, ikili arama uygulamasına da olanak tanır. Örneğin minimum sorgularını destekleyen bir ağaçta en küçük değere sahip eleman $O(\log n)$ zamanda bulunabilir; kökten yapraklara doğru inen yolda minimum değer izlenerek bu eleman tespit edilir.

9.4 Ek Teknikler

İndis Sıkıştırması

Bu bölümdeki veri yapıları ardışık sayılardan oluşan diziler üzerine kuruludur. Büyük indisler gerektiğinde (örneğin $10^9$ indisi) bellek yetersizliği sorunu ortaya çıkar. Bu sınır indis sıkıştırması ile aşılabilir.

Buradaki fikir, orijinal indisleri $1, 2, 3, \ldots$ gibi ardışık indislerle değiştirmektir. Bunun için algoritma çalışmaya başlamadan önce tüm indislerin bilinmesi gerekir. Sıkıştırma fonksiyonu $c$ sıralamayı korumalıdır: eğer $a < b$ ise $c(a) < c(b)$ olmalıdır. Bu sayede indisler sıkıştırılmış olsa bile sorgular doğru çalışır.

Örneğin orijinal indisler $8$, $555$ ve $10^9$ ise yeni indisler:

Aralık Güncellemeleri

Şimdiye kadar aralık sorguları yapıp tek eleman güncelleyebilen yapılar incelendi. Tam tersi durumda — aralık güncelleyip tek eleman okumada — fark dizisi kullanılır. Fark dizisindeki her değer, mevcut değer ile orijinal değer arasındaki farkı tutar; dolayısıyla orijinal dizi, fark dizisinin prefix toplam dizisidir.

Örneğin [3, 3, 1, 1, 1, 5, 2, 2] dizisinin fark dizisi:

3  0  -2  0  0  4  -3  0
0  1   2  3  4  5   6  7

Fark dizisinin avantajı, orijinal dizideki bir aralığı yalnızca iki elemanı değiştirerek güncelleyebilmesidir. Örneğin $[1, 4]$ aralığındaki tüm değerleri 5 artırmak için fark dizisindeki 1. konumu 5 artırıp 5. konumu 5 azaltmak yeterlidir:

Genel olarak $[a, b]$ aralığını $x$ kadar artırmak için $a$. konumu $x$ artırıp $b+1$. konumu $x$ azaltırız. Tek eleman güncellemesi ve toplam sorgusunun birlikte gerektiği bu yapı için ikili indisli ağaç veya segment ağacı kullanılır.

Hem aralık sorgularını hem de aralık güncellemelerini bir arada destekleyen daha gelişmiş yapılar Bölüm 28’de ele alınacaktır.