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.

Kısa Bir Tarih Yolculuğu

C’nin hikâyesi 1970’lerin başında Bell Laboratuvarları’nda başladı. Dennis Ritchie, Ken Thompson’ın geliştirdiği B dilinden esinlenerek daha güçlü ve taşınabilir bir dil tasarladı. Temel amaç, Unix işletim sistemini donanıma bağımlı Assembly kodları yerine daha üst seviyeli bir dille geliştirmekti.

Bu tercih büyük bir dönüşüm yarattı: Unix farklı bilgisayarlara daha kolay taşınırken C de sistem programlamanın ortak dili hâline geldi. Brian Kernighan ve Dennis Ritchie’nin 1978’de yayımladığı kitap, dilin ilk yaygın başvuru kaynağı oldu. Ardından ANSI C ya da C89 standardı geldi; C99, C11, C17 ve C23 sürümleri ise dili modern ihtiyaçlara göre geliştirdi.

Bir C Programının Anatomisi

C programları fonksiyonlardan oluşur ve yürütme genellikle main fonksiyonundan başlar. Kütüphaneler başlık dosyalarıyla programa tanıtılır. Değişkenler veriyi, ifadeler hesaplamayı, kontrol yapıları ise programın kararlarını temsil eder.

#include <stdio.h>

int kare(int sayi) {
    return sayi * sayi;
}

int main(void) {
    int deger = 6;
    int sonuc = kare(deger);

    printf("%d sayısının karesi: %d\n", deger, sonuc);
    return 0;
}

Burada #include <stdio.h> standart giriş-çıkış araçlarını bildirir. kare fonksiyonu aldığı tam sayıyı kendisiyle çarpar. Matematiksel olarak işlem

şeklinde gösterilebilir. main, değişkenleri oluşturur, fonksiyonu çağırır ve sonucu printf ile ekrana yazar. return 0 ifadesi de programın başarıyla tamamlandığını işletim sistemine bildirir.

C’de tür bilgisi önemlidir. Örneğin int tam sayıları, char karakterleri, float ve double ondalıklı değerleri saklar. Bir dizinin bellekte kapladığı yaklaşık alan şu ilişkiyle düşünülebilir:

Bu nedenle C, programcıya hem güç hem de sorumluluk verir; yanlış sınır kullanımı bellek hatalarına yol açabilir.

Kaynak Kod Nasıl Çalışan Programa Dönüşür?

C çoğunlukla derlenen bir dildir. Yazdığımız kaynak kod işlemci tarafından doğrudan anlaşılmaz. Dönüşüm zinciri genel olarak şöyledir:

GCC ile örnek program şöyle derlenebilir:

gcc -Wall -Wextra -std=c17 program.c -o program
./program

-Wall ve -Wextra, olası sorunlar hakkında uyarılar üretir; -std=c17 kullanılacak standardı seçer. Uyarıları görmezden gelmemek, C dünyasında emniyet kemeri takmaya benzer: Program yine ilerleyebilir ama ilk sert virajda farkı anlarsınız.

C’nin kalıcı etkisi; küçük çalışma zamanı, donanıma yakınlık, taşınabilirlik ve öngörülebilir performanstan gelir. Değişkenler, fonksiyonlar, koşullar ve döngüler temeli oluştururken derleme modelini anlamak hataları çözmeyi kolaylaştırır. Kısacası C, bilgisayara yalnızca ne yapacağını değil, bunu kaynakları nasıl kullanarak yapacağını da anlatmayı öğretir.

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.

Önce “yol” kavramını netleştirelim

Bir graf $G=(V,E)$, düğümlerden oluşan $V$ kümesi ile bu düğümleri bağlayan $E$ kenar kümesidir. Ağırlıklı bir grafta her kenarın $w(u,v)$ maliyeti bulunur. Bir $P$ yolunun toplam ağırlığı şöyle hesaplanır:

Buradaki kritik ayrıntı, aradığımız yapının basit yol olmasıdır; yani hiçbir düğüm birden fazla ziyaret edilemez. Tekrara izin verilseydi pozitif ağırlıklı bir döngünün çevresinde sonsuza kadar dolaşarak yol uzunluğunu sınırsız büyütebilirdik. Dolayısıyla anlamlı optimizasyon problemi, tekrar içermeyen en uzun yolu arar.

En kısa yol kolayken en uzun yol neden zor?

En kısa yol algoritmaları optimal alt yapıdan yararlanır. Bir düğüme ulaşmanın en iyi maliyeti bulunduğunda, özellikle negatif ağırlık yoksa bu karar güvenle kullanılabilir. En uzun basit yolda ise erken seçilen bir kenar, ileride ihtiyaç duyulan önemli bir düğümü tüketebilir. Yerel olarak uzun görünen seçim, küresel olarak kısa bir çıkmaza dönüşebilir.

Örneğin en ağır komşuya gitmeyi seçen açgözlü algoritma, birkaç adım sonra kapanan bir kola sapabilir. Daha hafif başlayan başka bir kol ise grafın neredeyse tamamını dolaşabilir. Algoritmanın bütün olası düğüm sıralamalarını hesaba katması gerekebilir; bu olasılık sayısı üstel biçimde büyür.

Hamilton Yolu bağlantısı

Zorluğu göstermenin klasik yolu, Hamilton Yolu Problemi ile ilişki kurmaktır. Hamilton yolu, graftaki her düğümü tam bir kez ziyaret eden basit bir yoldur ve bu karar problemi NP-tamdır.

Ağırlıksız bir grafta her kenara $1$ ağırlığını verelim. $\vert V\vert =n$ düğüm varsa Hamilton yolu tam olarak $n-1$ kenar içerir. Şu soruyu sorabiliriz:

Bu soruya cevap verebilen bir en uzun yol algoritması, Hamilton yolu olup olmadığını da belirler. Dönüşüm polinom zamanda yapıldığı için en uzun yol problemi NP-zordur. Ayrıca verilen bir yolun basit olduğunu ve hedef uzunluğa ulaştığını hızlıca doğrulayabildiğimizden karar sürümü NP-tamdır.

Her graf türünde umutsuz muyuz?

Hayır! Graf bir DAG, yani yönlendirilmiş döngüsüz graf ise topolojik sıralama sayesinde problem $O(\vert V\vert +\vert E\vert )$ zamanda çözülebilir. Döngü bulunmadığından geçmiş bir düğüme dönme ihtimali yoktur.

def longest_path_dag(vertices, edges, order, source):
    dist = {v: float("-inf") for v in vertices}
    dist[source] = 0

    for u in order:
        if dist[u] == float("-inf"):
            continue
        for v, weight in edges[u]:
            dist[v] = max(dist[v], dist[u] + weight)

    return dist

Kod, düğümleri topolojik sırayla işler. dist[v], kaynaktan v düğümüne bulunan en uzun mesafeyi saklar; her kenar yalnızca bir kez gevşetilir. Bu, en kısa yol gevşetmesine benzer, fakat min yerine max kullanılır.

Genel graflarda ise kesin çözüm için geri izleme, bitmask dinamik programlama veya dal-sınır yöntemleri kullanılabilir. Büyük örneklerde yaklaşım algoritmaları ve sezgiseller tercih edilir. Kısacası tek kelimelik “en” değişikliği, kolay bir rota probleminden kombinatoryal bir labirente geçmemize yeter!

Rüzgâr neden bir bozucudur?

Bir İHA’nın hareketi basitleştirilmiş biçimde Newton’un ikinci yasasıyla açıklanabilir:

Burada $\vec{F}_{rüzgar}$ kontrolcünün doğrudan yönetemediği dış kuvvettir. Rüzgârın sürükleme kuvveti yaklaşık olarak

ile modellenir. $\rho$ hava yoğunluğu, $C_d$ sürükleme katsayısı, $A$ rüzgâra maruz kalan alan ve $v_r$ bağıl hava hızıdır. Hızın karesi özellikle önemlidir: Rüzgâr iki katına çıktığında sürükleme yaklaşık dört katına çıkabilir. Küçük drone’un neden sert rüzgârda alışveriş poşeti gibi savrulduğu böylece anlaşılır.

Kontrol döngüleri nasıl çalışır?

Modern uçuş kontrolcüleri genellikle iç içe geçmiş kontrol döngüleri kullanır. En içte açısal hız, onun dışında tutum, daha dışta hız ve konum kontrolü bulunur. İç döngüler yüzlerce veya binlerce hertz hızında çalışırken GPS tabanlı konum döngüsü daha yavaştır.

Rüzgâr drone’u sağa sürüklediğinde konum kontrolcüsü sola doğru hız talep eder. Hız kontrolcüsü bu talebi bir eğim açısına dönüştürür; tutum kontrolcüsü de motorların devirlerini değiştirir. Sonuçta drone, rüzgâra doğru hafifçe yatıp konumunu korur.

PID kontrolünün rolü

Yaygın PID kontrol yasası şöyledir:

$K_p$ mevcut hataya tepki verir, $K_i$ sürekli rüzgârın oluşturduğu kalıcı kaymayı giderir, $K_d$ ise hızlı değişimleri sönümler. Fazla yüksek kazançlar titreşime, düşük kazançlar ise ağır ve yetersiz tepkiye yol açar.

Aşağıdaki örnek, yatay hız hatasından pitch komutu üreten sade bir PID döngüsüdür:

class PID:
    def __init__(self, kp, ki, kd):
        self.kp, self.ki, self.kd = kp, ki, kd
        self.integral = 0.0
        self.previous_error = 0.0

    def update(self, target, measured, dt):
        error = target - measured
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt
        self.previous_error = error
        return self.kp * error + self.ki * self.integral + self.kd * derivative

pid = PID(0.8, 0.15, 0.05)
pitch_command = pid.update(target=0.0, measured=1.2, dt=0.01)

Burada hedef hız sıfırdır; ölçülen pozitif hız rüzgâr kaynaklı sürüklenmeyi temsil eder. Üretilen pitch komutu, drone’un ters yönde kuvvet oluşturmasını sağlar. Gerçek sistemlerde integral taşmasını önleyen sınırlar, çıkış doyumu ve türev filtresi de eklenmelidir.

Dayanıklılığı artıran unsurlar

Başarılı rüzgâr dayanıklılığı yalnızca kontrol algoritmasına bağlı değildir. Düşük gürültülü IMU, doğru sensör füzyonu, rijit gövde, yeterli motor rezervi ve dengeli pervaneler birlikte çalışmalıdır. Kalman filtresi; jiroskop, ivmeölçer, barometre ve GPS verilerini birleştirerek daha güvenilir durum tahmini üretir.

Kontrolcü ayrıca motorların maksimum itki sınırını bilmelidir. Rüzgârı yenmek için gereken kuvvet fiziksel kapasiteyi aşarsa dünyanın en akıllı algoritması bile mucize yaratamaz. Bu nedenle dayanıklı bir İHA; iyi modellenmiş, doğru ayarlanmış, simülasyonda sınanmış ve kontrollü saha testleriyle doğrulanmış sistemdir. Kısacası rüzgârla kavga etmek yerine onu ölçer, tahmin eder ve motorlara doğru karşı hamleyi yaptı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.

İndirgeme nedir?

Bir $A$ problemini $B$ problemine indirgemek, $A$ probleminin girdilerini $B$ problemine ait girdilere dönüştüren bir yöntem oluşturmaktır. Dönüşümden sonra $B$ için elde edilen cevap, $A$ probleminin cevabını belirlemelidir.

Polinom zamanda gerçekleştirilen indirgeme genellikle şu şekilde gösterilir:

Bu ifade, “$A$, polinom zamanda $B$ problemine indirgenebilir” anlamına gelir. Süreç üç adımdan oluşur:

1. $A$ problemine ait $x$ girdisini al.
2. Polinom zamanda $f(x)$ dönüşümünü uygula.
3. $B$ problemini $f(x)$ üzerinde çözerek $A$ için sonucu yorumla.

Dönüşümün temel doğruluk koşulu şöyledir:

Yani özgün örnek “evet” örneğiyse dönüştürülen örnek de “evet” olmalıdır; aynı ilişki “hayır” cevapları için de korunmalıdır.

Basit bir örnek: yolculuk problemi

Bir şehir ağında iki nokta arasında yol bulunup bulunmadığını düşünelim. Şehirleri düğüm, yolları kenar olarak temsil edersek soru doğrudan graf erişilebilirliği problemine dönüşür. Harita ayrıntıları artık önemli değildir; elimizde yalnızca bir grafik vardır.

from collections import deque

def ulasilabilir_mi(graf, baslangic, hedef):
    kuyruk = deque([baslangic])
    ziyaret = {baslangic}

    while kuyruk:
        dugum = kuyruk.popleft()
        if dugum == hedef:
            return True

        for komsu in graf.get(dugum, []):
            if komsu not in ziyaret:
                ziyaret.add(komsu)
                kuyruk.append(komsu)

    return False

Bu kod, dönüştürülmüş graf üzerinde genişlik öncelikli arama yapar. Karmaşıklığı $O(V+E)$ düzeyindedir; burada $V$ şehir sayısını, $E$ ise yol sayısını temsil eder. Asıl indirgeme, gerçek dünyadaki şehir-yol modelini graf yapısına çevirmektir.

Yön neden önemlidir?

İndirgemelerde ok yönü sıkça karıştırılır. $A \leq_p B$ yazıyorsa $A$ problemini çözmek için $B$ kullanılır. Dolayısıyla $B$, en az $A$ kadar güçlü veya zor olabilir.

Örneğin SAT probleminin zor olduğu biliniyorsa ve $SAT \leq_p X$ gösterilebiliyorsa, $X$ probleminin de en az SAT kadar zor olduğu sonucuna ulaşılır. Ancak ters yönde indirgeme yapmak aynı sonucu vermez; matematiksel ok küçük görünse de bütün ispatı ters çevirebilir.

İyi bir indirgeme nasıl kurulur?

Önce iki problemin yapısal ortaklıkları bulunmalıdır. Değişkenler düğümlere, kısıtlar kenarlara veya seçimler mantıksal ifadelere karşılık gelebilir. Ardından dönüşümün polinom zamanda çalıştığı ve cevapları iki yönde de koruduğu kanıtlanır.

Kısacası indirgeme, “Bu problemi başka hangi dilde ifade edebilirim?” sorusudur. Doğru hedef seçildiğinde karmaşık bir soru tanıdık bir algoritmayla çözülebilir; bazen de çözüm üretmek yerine problemin neden zor olduğu gösterilir. Bu nedenle indirgeme yalnızca teknik bir ispat yöntemi değil, algoritmik düşünmenin en kullanışlı süper güçlerinden biridir.

``

SAT problemi nedir?

Bir Boole formülü; doğru veya yanlış değerlerini alabilen değişkenlerden ve AND ($\land$), OR ($\lor$), NOT ($\neg$) gibi bağlaçlardan oluşur. SAT problemi şu soruyu sorar:

Formülü doğru yapan en az bir değişken ataması var mı?

Örneğin

formülü için $x=1$, $y=0$ ve $z=1$ seçildiğinde iki parantez de doğru olur. Dolayısıyla $F$ sağlanabilirdir. Buna karşılık

hiçbir atamayla doğru yapılamaz; bu formül sağlanamazdır.

$n$ değişkenli bir formül için toplam $2^n$ olası atama vardır. Kaba kuvvet algoritması bunların tamamını dener. Bu yaklaşımın çalışma süresi yaklaşık olarak

olur. Üstel büyüme yüzünden birkaç yüz değişken bile bilgisayarı ciddi biçimde terletebilir.

P, NP ve NP-tamlık bağlantısı

SAT’ın önemini anlamak için temel karmaşıklık sınıflarını karşılaştıralım:

Birisi bize değişken atamasını sertifika olarak verirse formülü doğrusal ya da polinoma yakın sürede değerlendirebiliriz. Zor olan, bu sertifikayı bulmaktır.

1971 tarihli Cook–Levin Teoremi, SAT’ın NP-tam olduğunu gösterdi. Teoremin özündeki fikir şudur: NP’deki herhangi bir problemin polinom zamanlı hesaplama adımları, bir Boole formülüyle temsil edilebilir. Oluşturulan formül ancak ve ancak özgün problem örneğinin geçerli bir çözümü varsa sağlanabilir.

Bu dönüşüme polinom zamanlı indirgeme denir:

Buradaki ifade, $A$ probleminin örneklerini polinom zamanda SAT örneklerine çevirebildiğimizi anlatır. Bu nedenle SAT için polinom zamanlı bir algoritma bulunursa NP’deki bütün problemler polinom zamanda çözülebilir ve $P=NP$ sonucu elde edilir.

CNF ve 3-SAT neden sık kullanılır?

SAT formülleri çoğunlukla Konjonktif Normal Form ile yazılır. CNF, OR ile bağlanan değişmezlerin oluşturduğu tümcelerin AND ile birleştirilmesidir:

Her tümcede tam üç değişmez bulunan özel sürüme 3-SAT denir. Kısıtlı görünmesine rağmen 3-SAT da NP-tamdır. Bu düzenli yapı, başka problemlerin SAT’a veya SAT’tan başka problemlere indirgenmesini kolaylaştırır.

Küçük bir SAT çözücüsü

Aşağıdaki Python kodu bütün atamaları deneyerek verilen CNF formülünü çözer. Her tümce (değişken, negatif_mi) çiftlerinden oluşur:

from itertools import product

def solve_sat(variables, clauses):
    for values in product([False, True], repeat=len(variables)):
        assignment = dict(zip(variables, values))

        def literal_value(literal):
            variable, is_negative = literal
            value = assignment[variable]
            return not value if is_negative else value

        if all(any(literal_value(lit) for lit in clause)
               for clause in clauses):
            return assignment
    return None

clauses = [
    [("x", False), ("y", False)],
    [("x", True), ("z", False)]
]

print(solve_sat(["x", "y", "z"], clauses))

Kod öğretici olsa da üstel sayıda atama dener. Gerçek SAT çözücüleri DPLL, birim yayılımı, geri izleme ve CDCL gibi tekniklerle arama uzayının büyük bölümlerini eler. En kötü durum hâlâ üstel olabilir; ancak modern çözücüler milyonlarca değişken içeren pratik örneklerde şaşırtıcı derecede başarılıdır.

SAT’ın büyüsü burada yatar: Sorusu küçücük, sonuçları devasa! Devre doğrulama, paket bağımlılıkları, Sudoku, görev planlama ve yazılım testi gibi problemler Boole kısıtlarına çevrilebilir. Bu yüzden SAT yalnızca teorik bir bilmece değil, hem $P$ ile $NP$ arasındaki gizemin kapısı hem de güçlü bir mühendislik aracıdı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.