``

2-3 ağacı nedir?

Bir 2-3 ağacındaki iç düğüm iki biçimden birine sahiptir:

• 2-düğüm: Bir anahtar ve iki çocuk taşır.
• 3-düğüm: İki sıralı anahtar ve üç çocuk taşır.

Bir 3-düğümde anahtarlar $a < b$ ise sol alt ağaçtaki değerler $a$’dan küçük, ortadakiler $a$ ile $b$ arasında, sağdakiler ise $b$’den büyüktür. Böylece ikili arama ağacının sıralama mantığı korunurken tek seviyede daha fazla bilgi tutulur.

Asıl denge garantisi şu değişmezden gelir: Bütün yapraklar aynı derinliktedir. Ağacın yüksekliği $h$ ve anahtar sayısı $n$ olduğunda en seyrek durumda her düğüm iki çocukludur:

En yoğun durumda ise dallanma üçe yaklaşır. Dolayısıyla yükseklik kabaca

aralığındadır. Arama, ekleme ve silme işlemleri bu nedenle en kötü durumda $O(\log n)$ sürer.

Arama nasıl ilerler?

Her düğümde bir veya iki anahtar karşılaştırılır. Aranan değer küçükse sola, iki anahtarın arasındaysa ortaya, büyükse sağa gidilir. Yani bir seviyede daha çok karşılaştırma yapılabilir; buna karşılık ağaç genellikle daha kısadır.

Ekleme ve düğüm bölme

Yeni anahtar uygun yaprağa eklenir. Yaprak bir 2-düğümse anahtarlar sıralanır ve düğüm 3-düğüme dönüşür. Zaten iki anahtarı varsa geçici olarak üç anahtarlı bir taşma oluşur. Ortadaki anahtar ebeveyne gönderilir; küçük ve büyük anahtarlar iki ayrı düğüme bölünür. Ebeveyn de taşarsa işlem köke kadar devam eder. Kökün bölünmesi ağacın yüksekliğini yalnızca bir artırır.

Aşağıdaki Python kodu bu bölmenin özünü gösterir:

def split_keys(keys):
    """Üç sıralı anahtarı iki düğüm ve bir terfi anahtarına ayırır."""
    if len(keys) != 3:
        raise ValueError("Bölme için tam olarak üç anahtar gerekir")

    left = [keys[0]]
    promoted = keys[1]
    right = [keys[2]]
    return left, promoted, right

keys = sorted([40, 10, 25])
left, promoted, right = split_keys(keys)
print(left, promoted, right)  # [10] 25 [40]

Gerçek uygulamada çocuk işaretçileri de uygun yeni düğümlere dağıtılır. Kodun önemli fikri, ortanca anahtarın yukarı çıkarak sıralamayı ve eşit yaprak derinliğini korumasıdır.

Kırmızı-siyah bağlantısı

Bir 2-3 ağacını sıradan ikili bağlantılarla temsil etmek için 3-düğümdeki iki anahtar birbirine kırmızı bağlantıyla bağlanabilir. Tek başına duran 2-düğüm ise siyah bir düğüm olur:

• Siyah düğüm, bir 2-düğümü temsil eder.
• Siyah düğüm ile kırmızı çocuğu birlikte, bir 3-düğümü temsil eder.
• Kökten yapraklara eşit siyah düğüm sayısı, 2-3 ağacındaki eşit derinliğe karşılık gelir.

Özellikle sola yatık kırmızı-siyah ağaçlarda kırmızı bağlantı yalnızca sola eğilir. Ekleme sırasında yapılan sola döndürme, sağa döndürme ve renk değiştirme işlemleri; 2-3 ağacındaki düğüm birleştirme, bölme ve anahtar terfisinin ikili ağaç üzerindeki karşılıklarıdır.

Sonuç olarak 2-3 ağaçları dengeyi kavramsal olarak zarif biçimde garanti ederken kırmızı-siyah ağaçlar aynı fikri tek anahtarlı düğümlerle, pratik programlama ortamlarına daha uygun şekilde uygular. Renkler süs değil; görünmez 3-düğümleri işaretleyen küçük trafik lambalarıdır.

``

A* algoritmasının temel fikri

A*, ağırlıklı bir graf üzerinde başlangıç düğümünden hedef düğüme giden en düşük maliyetli yolu arar. Her düğüm için üç önemli değer kullanır:

• $g(n)$: Başlangıçtan $n$ düğümüne kadar ödenen gerçek maliyettir.
• $h(n)$: $n$ düğümünden hedefe kalan maliyetin tahminidir.
• $f(n)$: Düğüm üzerinden geçen yolun tahmini toplam maliyetidir.

Algoritma, sıradaki adım olarak $f(n)$ değeri en küçük olan düğümü seçer. Başka bir deyişle geçmişte ödediği maliyet ile gelecekte ödeyeceğini düşündüğü maliyeti birlikte değerlendirir.

Aslında $h(n)=0$ seçilirse A, Dijkstra algoritmasına dönüşür. Dolayısıyla A için Dijkstra’nın hedef bilgisiyle güçlendirilmiş hâli denebilir.

Sezgisel fonksiyon nasıl seçilir?

Kareli ve dört yönde hareket edilen bir haritada Manhattan uzaklığı kullanılabilir:

Çapraz hareket mümkünse Öklid uzaklığı daha uygun olabilir. A*‘ın en kısa yolu garanti etmesi için sezgisel fonksiyonun gerçek kalan maliyeti aşmaması gerekir. Bu özelliğe kabul edilebilirlik denir. Ayrıca tutarlı bir sezgi için her kenarda şu koşul sağlanır:

Tahmin çok küçükse algoritma güvenli fakat Dijkstra’ya yakın çalışır. Tahmin gereğinden büyükse daha hızlı görünebilir, ancak en kısa yol garantisi kaybolabilir.

Python ile A* uygulaması

Aşağıdaki kod, sözlük biçiminde tanımlanmış ağırlıklı bir graf üzerinde çalışır. Öncelik kuyruğu, tahmini toplam maliyeti en düşük düğümü verimli biçimde seçer.

from heapq import heappush, heappop

def a_star(graph, start, goal, heuristic):
    # Kuyruk elemanları: (f maliyeti, düğüm)
    open_set = [(heuristic(start, goal), start)]
    came_from = {}
    g_score = {start: 0}
    visited = set()

    while open_set:
        _, current = heappop(open_set)

        if current in visited:
            continue
        if current == goal:
            path = [current]
            while current in came_from:
                current = came_from[current]
                path.append(current)
            return path[::-1], g_score[goal]

        visited.add(current)

        for neighbor, edge_cost in graph[current]:
            tentative = g_score[current] + edge_cost

            if tentative < g_score.get(neighbor, float("inf")):
                came_from[neighbor] = current
                g_score[neighbor] = tentative
                f_score = tentative + heuristic(neighbor, goal)
                heappush(open_set, (f_score, neighbor))

    return None, float("inf")

Örnek olarak düğümlerin koordinatlarını ve bağlantılarını tanımlayabiliriz:

graph = {
    "A": [("B", 2), ("C", 4)],
    "B": [("A", 2), ("D", 3)],
    "C": [("A", 4), ("D", 1)],
    "D": [("B", 3), ("C", 1), ("E", 2)],
    "E": []
}

coords = {
    "A": (0, 0), "B": (1, 0), "C": (0, 1),
    "D": (1, 1), "E": (2, 1)
}

def manhattan(a, b):
    x1, y1 = coords[a]
    x2, y2 = coords[b]
    return abs(x1 - x2) + abs(y1 - y2)

path, cost = a_star(graph, "A", "E", manhattan)
print(path, cost)

Bu uygulama yolu A, B, D, E veya aynı maliyetli uygun bir alternatif olarak döndürebilir. A* özellikle oyun haritaları, robot navigasyonu ve rota planlama sistemlerinde güçlüdür. Yine de hız avantajı otomatik değildir: kötü bir sezgisel fonksiyon, büyük bellek tüketimi veya düzensiz graf yapısı performansı azaltabilir. İyi bir $h(n)$ seçimi ise A*‘ın gerçek süper gücüdür.

``

Union-Find hangi problemi çözer?

Elimizde başlangıçta birbirinden bağımsız $N$ eleman bulunduğunu düşünelim. Union-Find iki temel işlemi destekler:

• find(p): p elemanının bağlı olduğu kümenin kökünü bulur.
• union(p, q): p ve q elemanlarının kümelerini birleştirir.

Bu yapı; sosyal ağ bağlantıları, bilgisayar ağları, görüntü işleme, labirent üretimi ve Kruskal’ın minimum kapsayan ağaç algoritması gibi birçok alanda kullanılır.

Quick-Union yaklaşımında her eleman, ebeveyninin indeksini saklar. Bir kökte parent[i] == i olur. find, ebeveyn bağlantılarını köke ulaşıncaya kadar takip eder. Ne var ki birleşimler kötü sırayla yapılırsa ağaç bir zincire dönüşebilir.

Buradaki $α(N)$, ters Ackermann fonksiyonudur ve pratik veri boyutlarında neredeyse sabit kabul edilir.

Ağırlık neden işe yarar?

Her kök için ağacındaki eleman sayısını tutan bir size dizisi kullanılır. İki küme birleştirilirken küçük ağacın kökü, büyük ağacın köküne bağlanır. Böylece büyük ağaçtaki düğümlerin derinliği hiç değişmez; yalnızca küçük ağaçtaki düğümlerin derinliği bir artabilir.

Bir düğümün derinliği her arttığında, içinde bulunduğu ağacın büyüklüğü en az iki katına çıkar. Derinlik $h$ ise ağacın en az $2^h$ elemanı olmalıdır:

İşte performans garantisinin kalbi budur. Örneğin $N=1.000.000$ olduğunda zincir biçimli ağaç yaklaşık bir milyon adım gerektirebilirken ağırlıklı ağacın yüksekliği yaklaşık 20 ile sınırlıdır. Algoritmik diyet işe yarıyor: küçük ağaç, büyük ağacın sırtına biniyor!

Java ile uygulama

Aşağıdaki sınıf, ebeveynleri parent, ağaç büyüklüklerini ise size dizisinde saklar:

public class WeightedQuickUnion {
    private final int[] parent;
    private final int[] size;

    public WeightedQuickUnion(int n) {
        parent = new int[n];
        size = new int[n];

        for (int i = 0; i < n; i++) {
            parent[i] = i;
            size[i] = 1;
        }
    }

    public int find(int p) {
        validate(p);
        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    public boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    public void union(int p, int q) {
        int rootP = find(p);
        int rootQ = find(q);

        if (rootP == rootQ) return;

        if (size[rootP] < size[rootQ]) {
            parent[rootP] = rootQ;
            size[rootQ] += size[rootP];
        } else {
            parent[rootQ] = rootP;
            size[rootP] += size[rootQ];
        }
    }

    private void validate(int p) {
        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException();
        }
    }
}

find yalnızca köke yürür. union önce iki kökü bulur, ardından size değerlerini karşılaştırarak küçük ağacı büyük ağaca bağlar. Boyut bilgisinin yalnızca köklerde anlamlı olduğuna dikkat edilmelidir.

Bir adım daha: yol sıkıştırma

Performansı daha da artırmak için find döngüsüne şu satır eklenebilir:

parent[p] = parent[parent[p]];

Bu işlem, ziyaret edilen düğümü büyük ebeveynine bağlayarak yolu kısaltır. Ağırlıklandırma ağacın baştan fazla uzamasını önlerken yol sıkıştırma mevcut yolları düzleştirir. Birlikte kullanıldıklarında Union-Find işlemleri pratikte sabit zamana yakın çalışır. Sonuç olarak Weighted Quick-Union, küçük bir ek bellek maliyeti karşılığında kontrolsüz ağaç büyümesini engelleyen, basit ama son derece güçlü bir optimizasyondur.

``

Amortize analiz nedir?

Amortize analiz, bir işlemin olasılıksal ortalamasını değil, en kötü durumda oluşabilecek işlem dizisinin ortalama maliyetini inceler. Bu nedenle ortalama durum analizinden farklıdır: Kullanıcı davranışı veya rastgele veri dağılımı hakkında varsayım yapmaz.

$n$ işlemden oluşan bir dizinin toplam maliyeti $T(n)$ ise işlem başına amortize maliyet şöyle hesaplanır:

Örneğin toplam maliyet $T(n)=3n+10$ ise amortize maliyet:

Burada bazı işlemler tek başına pahalı olsa bile uzun vadede her işlem sabit maliyetli kabul edilebilir.

Klasik örnek: Dinamik dizi

Dinamik bir dizinin kapasitesi dolduğunda daha büyük bir alan ayrılır ve eski elemanlar yeni alana kopyalanır. Normal bir ekleme $O(1)$ sürerken yeniden boyutlandırma işlemi $O(n)$ maliyetli olabilir.

class DynamicArray:
    def __init__(self):
        self.capacity = 1
        self.size = 0
        self.data = [None] * self.capacity

    def append(self, value):
        if self.size == self.capacity:
            self._resize()

        self.data[self.size] = value
        self.size += 1

    def _resize(self):
        self.capacity *= 2
        new_data = [None] * self.capacity

        for i in range(self.size):
            new_data[i] = self.data[i]

        self.data = new_data

Bu kodda _resize, mevcut elemanları kopyalayarak kapasiteyi iki katına çıkarır. Boyutlandırmalar $1,2,4,8,\ldots$ elemanda gerçekleşir. $n$ ekleme boyunca yapılan toplam kopyalama sayısı:

Normal eklemelerin maliyeti de $n$ olduğundan toplam maliyet $2n$ civarındadır. Böylece işlem başına maliyet:

Tek bir ekleme $O(n)$ sürebilir; ancak append işleminin amortize maliyeti $O(1)$ olur. Pahalı taşınma masrafı, önceki ucuz eklemelere dağıtılmıştır.

Üç temel amortize analiz yöntemi

1. Toplam maliyet yöntemi

Tüm işlem dizisinin gerçek maliyeti hesaplanır ve işlem sayısına bölünür. Dinamik dizi örneğinde kullandığımız yaklaşım budur.

2. Muhasebe yöntemi

Ucuz işlemlerden gerçek maliyetlerinden biraz daha fazla ücret alınır. Aradaki kredi, gelecekteki pahalı işlemleri karşılamak üzere saklanır. Bir eklemenin gerçek maliyeti $1$ olsa da ona $3$ kredi biçtiğimizi düşünebiliriz. Fazladan kalan krediler yeniden boyutlandırmayı öder; algoritma adeta kendi kumbarasını taşır.

3. Potansiyel yöntemi

Veri yapısında biriken gelecekteki işi matematiksel bir potansiyel fonksiyonuyla gösteririz. Amortize maliyet:

Burada $c_i$ gerçek maliyet, $\Phi(D_i)$ ise işlemden sonraki potansiyeldir. Potansiyel artıyorsa geleceğe kredi bırakılır; azalıyorsa biriktirilen kredi pahalı işlemi karşılar.

Amortize analiz, tek bir kötü ana bakıp paniğe kapılmak yerine filmin tamamını izler. Dinamik diziler, hash tabloları, yığıt işlemleri ve birleşim-bulma yapıları bu yöntemle daha doğru değerlendirilir. Kısacası soru yalnızca “Bu işlem ne kadar pahalı?” değil, “Bu maliyet uzun bir yolculuk boyunca kaç işleme paylaşılıyor?” olmalıdır.

``

Tercihli oylamanın temel fikri

Üç adayımız olsun: Ada, Bora ve Ceren. Seçmenlerden adayları en beğendiklerinden en az beğendiklerine doğru sıralamalarını isteyelim. Sonuçlar şöyle olsun:

Burada yalnızca birinci tercihlere bakarsak Ada 4, Bora 3, Ceren 2 oy alır. Basit çoğulluk yöntemi Ada’yı kazanan ilan eder. Fakat sıralamanın geri kalanını da hesaba katarsak sonuç değişebilir.

Borda sayımı: Her sıraya puan

Borda yönteminde adaylar bulundukları sıraya göre puan kazanır. $m$ aday varsa birinci sıraya $m-1$, ikinci sıraya $m-2$ ve son sıraya $0$ puan verilebilir. Üç aday için puanlar sırasıyla $2$, $1$ ve $0$ olur.

Bir adayın toplam Borda puanı şu şekilde ifade edilir:

Burada $p_i(a)$, $i$ numaralı seçmenin $a$ adayına verdiği sıra puanıdır. Örneğimizde puanlar şöyledir:

Borda kazananı Bora’dır. Ada daha fazla seçmenin ilk tercihi olmasına rağmen birçok seçmen tarafından son sıraya konmuştur. Bora ise geniş bir uzlaşma sağlamıştır. Borda, güçlü sevgiyi ödüllendirirken genel kabulü de önemser.

Condorcet: Bire bir düello

Condorcet yaklaşımı puan toplamak yerine adayları ikili karşılaştırır. Bir aday, diğer bütün adayları bire bir seçimlerde yeniyorsa Condorcet kazananı olur.

Örneğin Bora ile Ada karşılaştırıldığında ilk gruptaki 4 seçmen Ada’yı, diğer 5 seçmen Bora’yı üstün tutar. Bora, Ada’yı $5$–$4$ yener. Bora ile Ceren karşılaşmasında ise ilk iki grup, yani 7 seçmen Bora’yı Ceren’in önüne koyar. Böylece Bora yine kazanır ve Condorcet kazananı olur.

Borda ve Condorcet her zaman aynı sonucu vermez. Ayrıca Condorcet kazananı bulunmayabilir: Ada Bora’yı, Bora Ceren’i, Ceren de Ada’yı yenebilir. Bu duruma Condorcet döngüsü denir; tercihler taş-kâğıt-makas oyununa dönüşür.

Küçük bir Python uygulaması

Aşağıdaki kod, sıralı oyların Borda puanlarını hesaplar:

from collections import defaultdict

oylar = [
    (4, ["Ada", "Bora", "Ceren"]),
    (3, ["Bora", "Ceren", "Ada"]),
    (2, ["Ceren", "Bora", "Ada"]),
]

puanlar = defaultdict(int)
aday_sayisi = len(oylar[0][1])

for secmen, siralama in oylar:
    for sira, aday in enumerate(siralama):
        puanlar[aday] += secmen * (aday_sayisi - sira - 1)

print(dict(puanlar))
print("Kazanan:", max(puanlar, key=puanlar.get))

Döngü, her adayın sıra puanını o tercihi paylaşan seçmen sayısıyla çarpar. Çıktıda Bora 12 puanla kazanır.

Sonuç olarak seçim yöntemi tarafsız bir ayrıntı değil, sonucun parçasıdır. Basit çoğulluk güçlü birinci tercihleri, Borda genel memnuniyeti, Condorcet ise bire bir üstünlüğü ölçer. Bu nedenle “Kim kazandı?” sorusundan önce “Oyları hangi kuralla saydık?” diye sormak gerekir.

``

Döviz piyasasını graf olarak modellemek

Her para birimini bir düğüm, mümkün olan her döviz dönüşümünü de yönlü bir kenar olarak düşünebiliriz. Örneğin USD’den EUR’ya geçiş ayrı, EUR’dan USD’ye geçiş ayrı bir kenardır; çünkü bu iki kur birbirinin tam tersi olmak zorunda değildir.

Elimizde şu dönüşüm zinciri olsun:

Başlangıçta 1 USD varsa zincirin sonunda elde edeceğimiz miktar:

Kurların çarpımı 1’den büyükse başlangıçtakinden daha fazla USD elde ederiz:

Ancak graf algoritmaları toplama işlemleriyle çalışmayı sever. Çarpımları toplama çevirmek için logaritmadan yararlanırız:

Negatif logaritma uygulandığında kârlılık koşulu şu hâle gelir:

Yani arbitraj fırsatı, dönüştürülmüş graf üzerindeki negatif ağırlıklı bir döngüdür.

Neden Bellman-Ford?

Dijkstra algoritması negatif kenar ağırlıklarıyla güvenilir biçimde çalışmaz. Bellman-Ford ise negatif ağırlıkları destekler ve ulaşılabilir negatif döngüleri belirleyebilir.

Algoritma, $V$ düğümlü bir grafta bütün kenarları $V-1$ kez gevşetir. Bu işlemlerden sonra herhangi bir mesafe hâlâ küçültülebiliyorsa negatif döngü vardır. Zaman karmaşıklığı $O(VE)$ seviyesindedir; para birimi sayısının genellikle sınırlı olması nedeniyle pratik bir seçimdir.

Python ile arbitraj tespiti

Aşağıdaki fonksiyon kurları negatif logaritmik ağırlıklara dönüştürür. Bütün düğümlerin başlangıç mesafesini sıfır yapmak, bağlantısız bileşenlerdeki döngüleri de aramamızı sağlar.

import math


def find_arbitrage(currencies, rates):
    n = len(currencies)
    edges = []

    for source, target, rate in rates:
        weight = -math.log(rate)
        edges.append((source, target, weight))

    distance = [0.0] * n
    parent = [-1] * n
    changed = -1

    for _ in range(n):
        changed = -1
        for source, target, weight in edges:
            if distance[target] > distance[source] + weight:
                distance[target] = distance[source] + weight
                parent[target] = source
                changed = target

    if changed == -1:
        return None

    # Düğümü döngünün içine taşır.
    vertex = changed
    for _ in range(n):
        vertex = parent[vertex]

    cycle = [vertex]
    current = parent[vertex]
    while current != vertex:
        cycle.append(current)
        current = parent[current]

    cycle.append(vertex)
    cycle.reverse()
    return [currencies[i] for i in cycle]


currencies = ["USD", "EUR", "GBP"]
rates = [
    (0, 1, 0.92),
    (1, 2, 0.87),
    (2, 0, 1.27),
]

print(find_arbitrage(currencies, rates))

Fonksiyon None döndürürse negatif döngü bulunamamıştır. Bir liste döndürürse listedeki para birimleri olası arbitraj rotasını gösterir. Örnekte kurların çarpımı yaklaşık $0.92 \times 0.87 \times 1.27 = 1.016$ olduğundan teorik olarak yüzde 1,6 civarında brüt kazanç vardır.

Gerçek hayattaki küçük ama önemli canavarlar

Teorik arbitraj ile uygulanabilir arbitraj aynı şey değildir. Alış-satış farkı, işlem komisyonu, ağ gecikmesi, likidite ve kur değişimleri kârı yok edebilir. Komisyon oranı $c$ ise dönüşümde çıplak kur yerine efektif kur kullanılmalıdır:

Ayrıca kayan nokta hataları yüzünden karşılaştırmalara küçük bir tolerans eklemek faydalıdır. Bellman-Ford fırsatı matematiksel olarak bulur; fırsatın gerçekten cüzdanınıza ulaşması ise veri kalitesine ve işlem hızına bağlıdır. Kısacası algoritma hazine haritasını çizer, fakat hazinenin yerinde duracağını garanti etmez!

``

Önce DAG nedir?

Yönlendirilmiş bir grafta kenarlar belirli bir yöne sahiptir. Örneğin $u \rightarrow v$ kenarı, yalnızca $u$ düğümünden $v$ düğümüne geçişi temsil eder. Grafın içinde yönlendirilmiş hiçbir döngü bulunmuyorsa bu yapı bir DAG’dır.

DAG’lar; görev planlama, ders ön koşulları, bağımlılık yönetimi, veri işleme hatları ve sürüm geçmişleri gibi doğal bir ilerleme sırası bulunan problemlerde sıkça görülür.

Döngünün bulunmaması, düğümleri topolojik olarak sıralayabilmemizi sağlar. Böyle bir sıralamada her $u \rightarrow v$ kenarı için $u$, listede $v$’den önce gelir. En kısa yol algoritmasının asıl süper gücü de budur.

Neden topolojik sıralama yeterli?

Başlangıç düğümünün uzaklığını $0$, diğer bütün uzaklıkları $∞$ kabul edelim. Düğümleri topolojik sırayla işlerken her kenar için gevşetme yaparız:

Burada $d[u]$, başlangıçtan $u$ düğümüne bilinen en kısa uzaklık; $w(u,v)$ ise kenarın ağırlığıdır. Bir düğüm işlendiğinde ona gelebilecek bütün önceki düğümler zaten değerlendirilmiştir. Dolayısıyla geriye dönüp uzaklığı tekrar tekrar düzeltmeye gerek kalmaz.

DAG algoritması negatif ağırlıklı kenarlarla da çalışır. Çünkü negatif bir kenarın uzaklıkları sonradan beklenmedik biçimde değiştireceği döngüsel bir geri dönüş yoktur. Negatif döngü zaten DAG tanımı gereği oluşamaz.

Python ile uygulama

Aşağıdaki fonksiyon önce DFS kullanarak topolojik sıralamayı oluşturur, ardından düğümleri bu sırada işleyerek kenarları gevşetir:

def dag_shortest_path(graph, start):
    visited = set()
    order = []

    def dfs(node):
        visited.add(node)
        for neighbor, _ in graph.get(node, []):
            if neighbor not in visited:
                dfs(neighbor)
        order.append(node)

    # Bağlantısız parçalar için tüm düğümleri dolaşır.
    for node in graph:
        if node not in visited:
            dfs(node)

    order.reverse()
    distance = {node: float('inf') for node in graph}
    distance[start] = 0

    for node in order:
        if distance[node] == float('inf'):
            continue

        for neighbor, weight in graph.get(node, []):
            candidate = distance[node] + weight
            if candidate < distance[neighbor]:
                distance[neighbor] = candidate

    return distance


graph = {
    'A': [('B', 4), ('C', 2)],
    'B': [('D', 3)],
    'C': [('B', -1), ('D', 5)],
    'D': []
}

print(dag_shortest_path(graph, 'A'))

Bu örnekte C → B kenarının ağırlığı negatiftir. Buna rağmen sonuç güvenle hesaplanır: A → C → B → D rotasının toplam maliyeti $2 + (-1) + 3 = 4$ olur. Doğrudan görünen yollar her zaman en hesaplı yollar değildir!

Karmaşıklık ve önemli ayrıntılar

Topolojik sıralama $O(V+E)$, bütün kenarların gevşetilmesi de $O(V+E)$ sürer. Böylece toplam zaman karmaşıklığı $O(V+E)$, ek alan gereksinimi ise $O(V)$ olur. Bu, grafın tamamını en azından bir kez incelemek zorunda olduğumuz düşünüldüğünde oldukça verimlidir.

Ancak algoritmayı kullanmadan önce grafın gerçekten asiklik olduğu doğrulanmalıdır. Döngü varsa topolojik sıralama üretilemez. Kahn algoritması sonunda işlenen düğüm sayısını kontrol etmek veya DFS sırasında renk tabanlı döngü tespiti yapmak bu doğrulama için uygundur.

Özetle DAG yapısı, “ilerideki bir düğüm geçmişi etkileyemez” garantisi verir. Bu garanti en kısa yol problemini tek yönlü, doğrusal ve hızlı bir hesaplamaya dönüştürür; bazen döngülerin yokluğu gerçekten de hayatı kolaylaştırır.

``

Karşılaştırma Olmadan Sıralama Fikri

Quick Sort, Merge Sort ve Heap Sort gibi klasik algoritmalar karşılaştırma tabanlıdır. Bu algoritmaların genel alt sınırı $\Omega(N \log N)$ karşılaştırmadır. Dizgi sıralamada her karşılaştırma birden fazla karakterin incelenmesini gerektirebildiği için gerçek maliyet daha da büyüyebilir.

Anahtar-indeks sayımı ise karakterleri, örneğin ASCII kodlarını, küçük tam sayılara dönüştürür. Alfabe büyüklüğü $R$, eleman sayısı $N$ olduğunda tek karakter için temel süreç şöyledir:

1. Her karakterin kaç kez geçtiğini say.
2. Sayımları başlangıç indekslerine dönüştür.
3. Öğeleri yardımcı diziye dağıt.
4. Sonucu ana diziye geri kopyala.

Bu işlemin zaman karmaşıklığı $O(N + R)$ olur. Buradaki önemli ayrıntı, dağıtımın kararlı olmasıdır: Aynı karaktere sahip öğelerin önceki göreli sırası korunur.

def counting_sort_by_char(words, index, alphabet_size=256):
    count = [0] * (alphabet_size + 1)
    output = [None] * len(words)

    for word in words:
        code = ord(word[index])
        count[code + 1] += 1

    for r in range(alphabet_size):
        count[r + 1] += count[r]

    for word in words:
        code = ord(word[index])
        output[count[code]] = word
        count[code] += 1

    return output

Bu yardımcı fonksiyon, sabit bir karakter konumuna göre kararlı sıralama yapar. count dizisindeki bir hücre frekansı, ön toplam işleminden sonra ise başlangıç konumunu temsil eder.

LSD: Sağdan Sola İlerlemek

LSD, yani Least Significant Digit, en sağdaki karakterden başlar ve sola doğru ilerler. Genellikle tüm anahtarların aynı uzunlukta olduğu durumlarda kullanılır. Plaka kodları, sabit uzunluklu kimlikler ve tarih biçimleri iyi örneklerdir.

def lsd_sort(words, width):
    result = list(words)
    for index in range(width - 1, -1, -1):
        result = counting_sort_by_char(result, index)
    return result

codes = ['B12', 'A90', 'B01', 'A12']
print(lsd_sort(codes, 3))

Sağdan başlanmasının nedeni kararlılıktır. Son basamağa göre oluşan düzen, daha önemli bir karakter işlendiğinde aynı karakterli grupların içinde korunur. $W$ karakterli $N$ dizgi için yaklaşık maliyet $O(W(N + R))$ seviyesindedir.

MSD: Soldan Başlayan Böl ve Yönet

MSD, yani Most Significant Digit, önce en soldaki karakteri işler. Ardından aynı karakterle başlayan grupları kendi içlerinde özyinelemeli olarak sıralar. Değişken uzunluktaki kelimelerde özel bir “karakter yok” değeri kullanılır.

Örneğin ar, ara ve armut karşılaştırılırken kısa kelimenin bittiğini gösteren değer, gerçek karakterlerden küçük kabul edilir. Böylece ar, diğer ikisinin önüne gelir.

Ne Zaman Daha Hızlıdır?

Karşılaştırmalı sıralama yaklaşık $N \log N$ adet karar verir; üstelik ortak ön eke sahip dizgilerde aynı karakterleri defalarca okuyabilir. LSD ve MSD ise alfabe küçükken karakterleri kovalar gibi doğrudan kutulara dağıtır. Özellikle $R$ sabit ve anahtar uzunluğu sınırlıysa doğrusal davranışa yaklaşırlar.

Bununla birlikte Unicode gibi çok büyük alfabelerde doğrudan devasa sayım dizileri kullanmak bellek israfına dönüşebilir. Küçük veri kümelerinde de Python’ın yerleşik sorted fonksiyonu, düşük sabit maliyetleri sayesinde daha hızlı olabilir. Kısacası LSD düzenli veri için güvenilir bir maratoncu, MSD ise ortak önekleri ustaca eleyen çevik bir sprinterdir.

``

Problemin kuralları

Dairede $n$ kişi bulunsun. Saymaya birinci kişiden başlayalım ve her $k$ adımda ulaşılan kişiyi eleyelim. Elenen kişinin hemen yanındaki kişiyle saymaya yeniden devam edelim. Amaç iki farklı sonucu hesaplamak olabilir:

1. Kişilerin elenme sırası,
2. Oyunda hayatta kalan son kişi.

Örneğin $n=7$ ve $k=3$ olsun. Kişiler 1, 2, 3, 4, 5, 6, 7 biçiminde numaralandırılır. İlk elenen kişi 3, sonraki kişi 6 olur. Dairenin sonuna gelindiğinde sayma başa döner.

Böylece elenme sırası $[3,6,2,7,5,1]$, kazanan ise 4 olur.

Matematiksel düşünce

Yalnızca kazananı arıyorsak problemi daha küçük problemlere indirebiliriz. Sıfır tabanlı indeks kullanan Josephus bağıntısı şöyledir:

Buradaki mod işlemi, dairenin sonundan sonra tekrar başa dönmemizi sağlar. İnsanları 1’den başlayarak numaralandırmak istediğimiz için nihai sonuca 1 ekleriz:

Bu yaklaşım $O(n)$ zamanda ve $O(1)$ ek bellekte çalışır. Ancak yalnızca kazananı verir; bütün elenme sırasını öğrenmek için daireyi ayrıca simüle etmeliyiz.

Python ile daireyi simüle etmek

Python’daki deque, iki uçtan hızlı ekleme ve çıkarma yapabilen bir kuyruktur. rotate metodu sayesinde sıradaki kişiyi kuyruğun başına taşıyabiliriz.

from collections import deque


def josephus_sirasi(kisi_sayisi, adim):
    if kisi_sayisi < 1 or adim < 1:
        raise ValueError("Kişi sayısı ve adım pozitif olmalıdır.")

    daire = deque(range(1, kisi_sayisi + 1))
    elenenler = []

    while len(daire) > 1:
        # İlk kişi zaten birinci sayıldığı için k-1 konum ilerliyoruz.
        daire.rotate(-(adim - 1))
        elenenler.append(daire.popleft())

    return elenenler, daire[0]


elenenler, kazanan = josephus_sirasi(7, 3)
print("Elenenler:", elenenler)
print("Kazanan:", kazanan)

Programın çıktısı şöyledir:

Elenenler: [3, 6, 2, 7, 5, 1]
Kazanan: 4

rotate(-(adim - 1)) işlemi kuyruğu sola döndürür. Böylece elenecek kişi başa gelir; popleft() da onu daireden çıkarır. Negatif döndürme miktarı büyük olsa bile deque, döngüsel davranışı korur.

Yalnızca kazananı bulmak

Büyük girişlerde elenme listesini saklamak istemiyorsak bağıntıyı döngüyle uygulayabiliriz:

def josephus_kazanan(n, k):
    konum = 0
    for mevcut_boyut in range(2, n + 1):
        konum = (konum + k) % mevcut_boyut
    return konum + 1

Josephus Problemi küçük bir oyun gibi görünse de modüler aritmetik, kuyruklar, yinelemeli bağıntılar ve performans karşılaştırmaları için güçlü bir örnektir. Adım değerini veya başlangıç kişisini değiştirerek farklı senaryolar üretmek, algoritmanın döngüsel mantığını iyice pekiştirir.

Bir sosyal ağda Ayşe, Berk’in paylaşımlarına; Berk, Ceren’in paylaşımlarına; Ceren de Ayşe’nin paylaşımlarına ulaşabiliyorsa bu üçlü kapalı bir iletişim bölgesi oluşturur. Yönlü graflarda bu tür karşılıklı erişilebilir düğüm gruplarına güçlü bağlı bileşen denir. Kosaraju-Sharir algoritması, yalnızca iki derinlik öncelikli arama yaparak bu gizli toplulukları ortaya çıkarır. ``

Güçlü bağlılık nedir?

Bir yönlü grafı $G=(V,E)$ ile gösterelim. $u$ düğümünden $v$ düğümüne yönlü bir yol varsa bunu $u \rightsquigarrow v$ biçiminde yazabiliriz. İki düğümün aynı güçlü bağlı bileşende bulunması için şu koşul sağlanmalıdır:

Yani yalnızca ileri gitmek yetmez; geri dönebilmek de gerekir. Bu ilişki dönüşlü, simetrik ve geçişli olduğundan düğümleri birbirinden ayrık sınıflara böler.

Her düğüm tek başına da güçlü bağlı sayılır. Ancak algoritmanın asıl eğlenceli kısmı, döngüler ve karmaşık bağlantılar arasındaki daha büyük bileşenleri bulmasıdır.

Algoritmanın temel fikri

Kosaraju-Sharir üç aşamada çalışır:

1. Orijinal grafta DFS yap ve düğümleri bitiş zamanlarına göre kaydet.
2. Bütün kenarları ters çevirerek $G^T$ transpoz grafını oluştur.
3. Düğümleri azalan bitiş zamanı sırasıyla ele alıp $G^T$ üzerinde yeniden DFS yap.

İkinci turdaki her DFS ağacı tam olarak bir güçlü bağlı bileşen verir. İlk arama, hangi bileşenin önce ziyaret edilmesi gerektiğini belirleyen bir pusula gibidir.

Bir güçlü bağlı bileşeni tek bir süper düğüme sıkıştırırsak ortaya döngüsüz bir yoğunlaşma grafı çıkar. Bu graf bir DAG’dir. İlk DFS’nin bitiş sırası, ikinci geçişte başka bileşenlere yanlışlıkla taşmamızı önleyecek bir sıralama üretir. Kenarlar ters çevrilince bileşenlerin içindeki karşılıklı erişim korunur, bileşenler arasındaki geçiş yönleri ise değişir.

Python ile uygulama

Aşağıdaki kod, komşuluk listesiyle verilen bir graftaki bileşenleri döndürür:

def kosaraju(graph):
    visited = set()
    finish_order = []

    def first_dfs(node):
        visited.add(node)
        for neighbor in graph[node]:
            if neighbor not in visited:
                first_dfs(neighbor)
        finish_order.append(node)

    for node in graph:
        if node not in visited:
            first_dfs(node)

    transpose = {node: [] for node in graph}
    for node, neighbors in graph.items():
        for neighbor in neighbors:
            transpose[neighbor].append(node)

    visited.clear()
    components = []

    def second_dfs(node, component):
        visited.add(node)
        component.append(node)
        for neighbor in transpose[node]:
            if neighbor not in visited:
                second_dfs(neighbor, component)

    while finish_order:
        node = finish_order.pop()
        if node not in visited:
            component = []
            second_dfs(node, component)
            components.append(component)

    return components

İlk first_dfs, bir düğümü ancak bütün komşuları tamamlandıktan sonra listeye ekler. Listenin sonundan eleman almak azalan bitiş sırasını sağlar. second_dfs ise transpoz grafta ulaşabildiği düğümleri aynı bileşende toplar.

Karmaşıklık ve kullanım alanları

Her düğüm ve kenar sabit sayıda işlendiği için zaman karmaşıklığı

olur. Graf, transpoz yapı, ziyaret kümeleri ve DFS yığını için gereken bellek de $O(\vert V\vert +\vert E\vert )$ düzeyindedir.

Kosaraju-Sharir; sosyal ağ toplulukları, paket bağımlılık döngüleri, web bağlantıları, çağrı grafları ve durum makinelerinin analizinde kullanılabilir. İki DFS ile koskoca bir yönlü grafın içindeki karşılıklı ulaşılabilir adaları bulmak, algoritmanın hem zarif hem de pratik olmasının temel nedenidir.