Asıl sorun: Disk erişimi pahalıdır

RAM üzerindeki verilere erişmek son derece hızlıdır; ancak kalıcı veriler SSD veya sabit diskte tutulur. Diskten tek bir bayt yerine genellikle sayfa ya da blok adı verilen sabit boyutlu veri parçaları okunur. Bir sayfanın boyutu örneğin 4 KB, 8 KB veya 16 KB olabilir.

Bu nedenle disk tabanlı bir veri yapısında temel maliyet, yapılan karşılaştırmalar değil, okunan sayfa sayısıdır. Bir milyon kayıt arasında ikili arama teorik olarak

adım gerektirir. Fakat her düğüm ayrı bir disk sayfasındaysa yaklaşık 20 disk erişimi oldukça pahalı olabilir. B-ağaçları ise bir düğümde çok sayıda anahtar saklayarak ağacın dallanma katsayısını büyütür.

B-ağacının temel mantığı

İkili arama ağacındaki her düğüm en fazla iki çocuğa sahiptir. B-ağacında ise bir düğüm onlarca, hatta yüzlerce çocuk barındırabilir. Düğüm boyutu genellikle bir disk sayfasını dolduracak şekilde seçilir.

Bir B-ağacının dallanma katsayısı $m$ ise yaklaşık yüksekliği şöyledir:

Örneğin bir düğüm 100 çocuk gösterebiliyorsa bir milyon kayıt için:

Yani teorik olarak yalnızca üç sayfa okumasıyla hedef bölgeye ulaşılabilir. Üst düğümlerin önbellekte tutulması durumunda gerçek disk erişimi daha da azalır.

Arama nasıl gerçekleştirilir?

Her düğümde anahtarlar sıralı tutulur. Aranan değer düğümdeki anahtarlarla karşılaştırılır ve uygun çocuk sayfasına geçilir. Aşağıdaki sadeleştirilmiş Python kodu, bellekteki bir B-ağacı düğümünde bu yönlendirmeyi gösterir:

class BTreeNode:
    def __init__(self, keys, children=None, leaf=False):
        self.keys = keys
        self.children = children or []
        self.leaf = leaf

    def search(self, target):
        index = 0

        while index < len(self.keys) and target > self.keys[index]:
            index += 1

        if index < len(self.keys) and target == self.keys[index]:
            return self.keys[index]

        if self.leaf:
            return None

        return self.children[index].search(target)

Kod, önce hedefin hangi anahtar aralığında bulunduğunu belirler. Düğüm yaprak değilse yalnızca ilgili çocuğa ilerler. Gerçek veritabanlarında children listesindeki öğeler çoğunlukla nesne değil, disk sayfalarının adresleridir. Ayrıca düğüm içindeki arama doğrusal tarama yerine ikili aramayla yapılabilir.

Ekleme ve bölünme

Bir düğüm dolduğunda yeni kayıt gelişigüzel başka bir yere konmaz. Düğüm iki parçaya bölünür ve ortadaki anahtar üst düğüme taşınır. Üst düğüm de dolarsa bölünme köke kadar ilerleyebilir. Kök bölündüğünde ağacın yüksekliği yalnızca bir artar.

Bu kurallar bütün yaprakların aynı seviyede kalmasını sağlar. Böylece kötü sıralanmış eklemeler bile ağacı uzun bir zincire dönüştüremez. Arama, ekleme ve silme işlemlerinin maliyeti genel olarak $O(\log_m n)$ seviyesindedir.

B+ ağaçları neden daha yaygın?

Modern veritabanları çoğunlukla B-ağacının bir türevi olan B+ ağacını kullanır. İç düğümler yalnızca yönlendirme anahtarlarını içerirken gerçek kayıtlar yapraklarda saklanır. Yapraklar birbirine bağlı olduğundan WHERE yas BETWEEN 20 AND 30 gibi aralık sorguları, ilk kayıt bulunduktan sonra sayfalar üzerinde sıralı biçimde ilerleyebilir.

Kısacası B-ağaçlarının gücü yalnızca hızlı arama yapmalarından gelmez. Disk sayfalarıyla uyumlu çalışmaları, dengelerini korumaları ve yüksek dallanma katsayıları sayesinde milyonlarca kaydı birkaç disk erişimine indirgemeleri onları veritabanı indekslerinin vazgeçilmez kahramanı yapar.

Bir metnin içinde en az iki kez geçen en uzun parça hangisidir? İlk bakışta bütün alt dizgileri üretip karşılaştırmak makul görünebilir. Ancak metin büyüdüğünde bu yöntem, samanlıkta iğne ararken önce bütün samanları tek tek numaralandırmaya dönüşür. Son ek dizisi ve LCP dizisi ise tekrarları düzenli, hızlı ve şaşırtıcı derecede zarif biçimde ortaya çıkarır. ``

Problem tam olarak nedir?

Bir $S$ metni verildiğinde, metin içinde farklı başlangıç konumlarında en az iki kez bulunan en uzun alt dizgiyi ararız. Örneğin banana metninde cevap ana olur:

• İlk geçiş: b[ana]na
• İkinci geçiş: ban[ana]

Geçişlerin çakışmasına izin verilebilir. Örneğin aaaa içinde aaa, 0 ve 1 indislerinden başlayarak iki kez görünür.

Naif yaklaşım tüm alt dizgileri karşılaştırır. Uzunluğu $n$ olan bir metinde yaklaşık $n(n+1)/2$ alt dizgi bulunduğundan maliyet hızla büyür.

Son ek dizisi neden işe yarar?

Bir son ek, metnin herhangi bir konumundan başlayıp sona kadar giden parçadır. banana için son ekler şöyledir:

Bunlar alfabetik sıralandığında başlangıç indisleri [5, 3, 1, 0, 4, 2] olur. Bu indis listesine son ek dizisi denir.

Kritik fikir şudur: Ortak başlangıca sahip son ekler alfabetik sıralamada yan yana gelir. Dolayısıyla bütün son ek çiftlerini karşılaştırmak yerine yalnızca komşuları incelemek yeterlidir.

Komşu son eklerin ortak önek uzunluklarını tutan yapıya LCP (Longest Common Prefix) dizisi denir. Aradığımız sonuç:

banana için en büyük LCP değeri 3’tür; ilgili parça anadır.

Python ile çözüm

Aşağıdaki uygulama, son ek dizisini önek katlama yöntemiyle kurar. Her turda karşılaştırılan önek uzunluğu iki katına çıkar. Ardından Kasai algoritması LCP dizisini doğrusal zamanda hesaplar.

def suffix_array(text):
    n = len(text)
    sa = list(range(n))
    rank = [ord(ch) for ch in text]
    k = 1

    while k < n:
        sa.sort(key=lambda i: (
            rank[i],
            rank[i + k] if i + k < n else -1
        ))

        new_rank = [0] * n
        for j in range(1, n):
            previous, current = sa[j - 1], sa[j]
            prev_key = (rank[previous],
                        rank[previous + k] if previous + k < n else -1)
            curr_key = (rank[current],
                        rank[current + k] if current + k < n else -1)
            new_rank[current] = new_rank[previous] + (prev_key != curr_key)

        rank = new_rank
        if rank[sa[-1]] == n - 1:
            break
        k *= 2

    return sa


def longest_repeated_substring(text):
    if not text:
        return ""

    sa = suffix_array(text)
    rank = [0] * len(text)
    for position, suffix_start in enumerate(sa):
        rank[suffix_start] = position

    best_length = best_start = common = 0

    for i in range(len(text)):
        position = rank[i]
        if position == 0:
            continue

        j = sa[position - 1]
        while (i + common < len(text) and
               j + common < len(text) and
               text[i + common] == text[j + common]):
            common += 1

        if common > best_length:
            best_length, best_start = common, i

        common = max(0, common - 1)

    return text[best_start:best_start + best_length]


print(longest_repeated_substring("banana"))  # ana

Kasai algoritmasındaki common değerinin her adımda tamamen sıfırlanmaması önemlidir. Bir sonraki son eke geçildiğinde ortak önek uzunluğu en fazla bir azalır; böylece tekrar tekrar aynı karakterleri okumaktan kaçınılır.

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

Bu Python uygulamasında sıralama nedeniyle son ek dizisinin kurulması yaklaşık $O(n \log^2 n)$, LCP hesabı ise $O(n)$ sürer. Özel sıralama teknikleriyle toplam süre $O(n \log n)$, gelişmiş yöntemlerle $O(n)$ seviyesine indirilebilir.

Aynı yaklaşım DNA dizilerindeki tekrarları, belgelerdeki kopya bölümleri, sıkıştırılabilir kalıpları ve kod içindeki benzer parçaları bulmak için kullanılabilir. Kısacası son ek dizisi, metni yalnızca sıralamaz; görünmeyen tekrarların yan yana gelmesini sağlayarak problemi kolay bir maksimum aramasına dönüştürür.

``

LZW’nin temel mantığı

LZW, Terry Welch tarafından LZ78 yaklaşımının geliştirilmesiyle ortaya çıkarılmıştır. Algoritmanın en güzel taraflarından biri, kodlayıcı ile kod çözücünün sözlüğü verinin içine ayrıca eklemesine gerek bırakmamasıdır. Her iki taraf da aynı başlangıç sözlüğünü kullanır ve veriyi işlerken aynı yeni girdileri üretir.

Başlangıç sözlüğünde genellikle kullanılan alfabenin bütün tek karakterleri bulunur. Örneğin ASCII tabanlı bir uygulamada 0–255 arasındaki kodlar hazırdır. Algoritma girdiyi soldan sağa tarar, sözlükte bulunan en uzun diziyi arar ve bu dizinin kodunu çıktıya ekler. Ardından dizinin sonuna gelen yeni karakterle oluşturulan daha uzun kalıbı sözlüğe kaydeder.

Bu davranışı kabaca şöyle ifade edebiliriz:

Burada $W$, sözlükte bulunan mevcut diziyi; $K$, sıradaki karakteri; $W’$ ise sözlüğe eklenmeye aday yeni kalıbı temsil eder. $W’$ sözlükteyse tarama devam eder. Değilse $W$ kodlanır, $W’$ sözlüğe eklenir ve yeni arama $K$ ile başlar.

Küçük bir örnek

ABABABA girdisini düşünelim. Başlangıç sözlüğünde A ve B zaten bulunsun. Algoritma önce A kodunu üretir ve AB kalıbını sözlüğe ekler. Sonra B kodlanırken BA eklenir. Tarama ilerlediğinde AB artık tek bir sözlük girdisi olarak tanınır. Daha sonra ABA da öğrenilir. Başlangıçta tek tek görülen karakterler, algoritmanın hafızasında giderek daha büyük parçalara dönüşür.

Sıkıştırma oranı genel olarak şu şekilde hesaplanabilir:

$R < 1$ olması sıkıştırmanın işe yaradığını gösterir. Ancak veri rastgele veya çok kısa ise sözlük kodları ek yük oluşturabileceğinden LZW her zaman kazanç sağlamaz.

Python ile LZW sıkıştırma

Aşağıdaki fonksiyon, başlangıç sözlüğünü 256 karakterle kurar ve keşfettiği kalıplara artan sayısal kodlar verir:

def lzw_compress(text):
    dictionary = {chr(i): i for i in range(256)}
    next_code = 256
    current = ""
    output = []

    for char in text:
        candidate = current + char

        if candidate in dictionary:
            current = candidate
        else:
            output.append(dictionary[current])
            dictionary[candidate] = next_code
            next_code += 1
            current = char

    if current:
        output.append(dictionary[current])

    return output

print(lzw_compress("ABABABA"))

current, sözlükte bulunan en uzun kalıbı tutar. candidate sözlükte yoksa mevcut kalıbın kodu çıktıya gönderilir ve yeni kalıp öğrenilir. Fonksiyonun ürettiği sayılar doğrudan bit düzeyinde paketlenmediği için bu örnek öğretim amaçlıdır. Gerçek sistemlerde kodlar 9, 10 veya 12 bitlik alanlara yerleştirilerek dosya boyutu gerçekten azaltılır.

Nerelerde kullanılır?

LZW özellikle GIF görüntü formatında ve bazı TIFF dosyalarında tanınır. Metinlerdeki, çizimlerdeki ve sınırlı renk paletine sahip görüntülerdeki tekrarlar algoritma için oldukça lezzetli lokmalardır. Buna karşılık modern fotoğraflar veya şifrelenmiş veriler daha düzensiz olduğundan sözlüğün büyümesine rağmen yeterli tekrar sunmayabilir.

Sonuç olarak LZW, veriyi önceden analiz etmeden kalıpları öğrenen zarif bir algoritmadır. Bir bakıma okudukça kelime öğrenen ve uzun cümleleri küçük notlarla hatırlayan dijital bir stenograf gibi davranır.

``

Son ek nedir?

Bir metnin belirli bir konumundan sonuna kadar uzanan parçaya son ek denir. Örneğin banana metninin son ekleri şöyledir:

Bu son ekleri sözlük sırasına koyduğumuzda a, ana, anana, banana, na, nana sıralamasını elde ederiz. Son ek dizisi, parçaların kendileri yerine başlangıç indislerini tutar:

Buradaki temel fikir basittir: Aradığımız kalıpla başlayan bütün son ekler, sıralı listede yan yana bulunur. Böylece metni soldan sağa taramak yerine son ekler üzerinde ikili arama yapabiliriz.

Neden daha hızlıdır?

Uzunluğu $n$ olan bir metinde, uzunluğu $m$ olan bir kalıbı klasik yöntemle aramak en kötü durumda $O(nm)$ zaman alabilir. Son ek dizisi hazırsa ikili arama yaklaşık $O(\log n)$ karşılaştırma yapar. Her karşılaştırmada en fazla $m$ karakter incelendiği için sorgu maliyeti:

olur. Yapının hazırlanması ayrıca maliyetlidir; fakat aynı metin üzerinde binlerce sorgu yapılacaksa bu yatırım kısa sürede karşılığını verir.

Son ek dizisi, son ek ağacına göre daha kompakt olması ve önbellek dostu ardışık bir dizi kullanması nedeniyle pratikte oldukça çekicidir.

Python ile basit kurulum

Aşağıdaki eğitim amaçlı uygulama, bütün başlangıç indislerini karşılık gelen son eklere göre sıralar:

def suffix_array(text):
    # Her indis, text[i:] son ekinin anahtarıyla sıralanır.
    return sorted(range(len(text)), key=lambda i: text[i:])

text = "banana"
sa = suffix_array(text)
print(sa)  # [5, 3, 1, 0, 4, 2]

Kod oldukça okunaklıdır; ancak text[i:] işlemi yeni dizgiler oluşturduğu için büyük verilerde pahalıdır. Üretim seviyesindeki algoritmalar, son ekleri doğrudan kopyalamak yerine sıralama derecelerini kullanır. Prefix doubling yaklaşımı önce bir karakterlik, ardından 2, 4, 8 karakterlik önekleri karşılaştırır ve yaklaşık $O(n \log n)$ sürede çalışır.

Kalıp arama

Python’ın bisect modülü doğrudan özel karşılaştırıcı kabul etmediğinden, mantığı açıkça gösteren bir ikili arama yazabiliriz:

def find_pattern(text, sa, pattern):
    left, right = 0, len(sa)

    while left < right:
        mid = (left + right) // 2
        piece = text[sa[mid]:sa[mid] + len(pattern)]

        if piece < pattern:
            left = mid + 1
        else:
            right = mid

    start = left
    matches = []
    while start < len(sa) and text.startswith(pattern, sa[start]):
        matches.append(sa[start])
        start += 1
    return sorted(matches)

print(find_pattern("banana", [5, 3, 1, 0, 4, 2], "ana"))
# [1, 3]

İkili arama ilk eşleşmenin sınırını bulur; ardından yan yana duran eşleşmeler toplanır. Sonuç sayısı $k$ ise toplam maliyet yaklaşık $O(m \log n + km)$ olur.

LCP ile bir adım ileri

Son ek dizisinin sık kullanılan yardımcısı LCP dizisidir. LCP, komşu iki sıralı son ekin en uzun ortak önek uzunluğunu saklar. Örneğin ana ile anana arasındaki ortak önek uzunluğu 3’tür. En büyük LCP değeri, metindeki en uzun tekrarlanan parçayı gösterebilir.

Kısacası son ek dizisi, “bütün parçaları sakla” yaklaşımı değil, “başlangıçları akıllıca sırala” yaklaşımıdır. Metin sabit, sorgu sayısı fazlaysa bu mütevazı indis listesi gerçek bir arama roketine dönüşür.

``

Zaman adımlı ve olay-güdümlü yaklaşım

Geleneksel zaman adımlı benzetimde saat, sabit bir $\Delta t$ miktarıyla ilerletilir. Bir parçacığın yeni konumu yaklaşık olarak

şeklinde hesaplanır. $\Delta t$ küçüldükçe sonuç genellikle daha hassas olur, fakat işlem sayısı artar. Üstelik hızlı parçacıklar büyük bir zaman adımında birbirlerinin içinden geçebilir. Buna tünelleme problemi denir.

Olay-güdümlü yaklaşımda ise sistemin gelecekteki çarpışma zamanları hesaplanır. Benzetim saati en yakın olaya taşınır, ilgili parçacıkların durumları değiştirilir ve bu değişiklikten etkilenen yeni olaylar planlanır.

Çarpışma zamanı nasıl bulunur?

Yarıçapları $r_1$ ve $r_2$ olan iki parçacığın konum farkını $\Delta\vec{x}$, hız farkını da $\Delta\vec{v}$ olarak tanımlayalım. Çarpışma anında merkezler arasındaki uzaklık, yarıçapların toplamına eşittir:

Denklemin karesi alındığında $at^2+bt+c=0$ biçiminde ikinci dereceden bir denklem elde edilir. Pozitif ve en küçük kök, gelecekteki ilk çarpışma zamanıdır. Diskler birbirinden uzaklaşıyorsa veya diskriminant negatifse çarpışma olayı oluşturulmaz.

Çarpışma gerçekleştiğinde hızlar momentum ve enerji korunumu kullanılarak güncellenir. Toplam momentum için

olmalıdır. Esnek çarpışmada kinetik enerji de korunur. Böylece benzetim yalnızca görsel olarak değil, fiziksel olarak da tutarlı kalır.

Öncelik kuyruğu: Benzetimin ajandası

Gelecekteki olaylar, olay zamanına göre sıralanan bir öncelik kuyruğunda tutulur. En yakın olay kuyruğun başından alınır. Python’daki heapq, bu iş için uygun bir min-heap sağlar.

import heapq

queue = []
current_time = 0.0

def schedule(time, kind, particles):
    # Olayları gerçekleşme zamanına göre kuyruğa ekler.
    heapq.heappush(queue, (time, kind, particles))

schedule(1.25, "collision", (0, 3))
schedule(0.80, "wall", (2,))

while queue:
    event_time, kind, particles = heapq.heappop(queue)
    current_time = event_time

    if kind == "collision":
        resolve_collision(*particles)
    elif kind == "wall":
        reflect_from_wall(*particles)

    predict_new_events(particles, current_time)

Kod, zamanı küçük adımlarla artırmaz; saati doğrudan event_time değerine taşır. Olay işlendikten sonra yalnızca etkilenen parçacıklarla ilgili tahminlerin yenilenmesi önemli bir optimizasyondur.

Geçersiz olaylar ve pratik zorluklar

Bir parçacık için önceden hesaplanan olay, araya başka bir çarpışma girdiğinde geçersiz olabilir. Her parçacıkta bir çarpışma sayacı tutularak olay oluşturulurken sayaç değerleri kaydedilebilir. Olay işlenmeden önce değerler karşılaştırılır; uyuşmuyorsa eski olay çöpe atılır.

Olay-güdümlü benzetim her problem için sihirli değnek değildir. Yerçekimi veya sürtünme gibi sürekli etkiler baskınsa olay zamanlarını analitik biçimde bulmak zorlaşır. Buna karşılık seyrek ve ani değişimlerin bulunduğu sistemlerde, zamanı adımlamak yerine olaydan olaya zıplamak hem daha hızlı hem de daha hassas bir dijital evren kurar.

``

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.