``

Erişilebilirlik: Çöpün matematiksel tanımı

Belleği yönlü bir grafik olarak düşünelim. Her nesne bir düğüm, nesneler arasındaki referanslar ise kenardır. Programın doğrudan erişebildiği global değişkenler, aktif çağrı yığınları ve CPU kayıtları kök kümesini oluşturur.

Kök kümesi $R$, tüm nesneler kümesi $V$ ve erişilebilir nesneler kümesi $L$ olsun:

Dolayısıyla çöp kümesi şöyledir:

Bir nesnenin başka bir nesne tarafından işaret edilmesi tek başına yeterli değildir. Birbirini gösteren iki sahipsiz nesne de çöptür; çünkü köklerden ikisine de ulaşılamaz. Bu ayrıntı, yalnızca referans saymaya dayalı yöntemlerin döngüler karşısında neden zorlandığını açıklar.

Mark-sweep nasıl çalışır?

Mark-sweep, adını iki temel aşamasından alır:

1. Mark: Köklerden başlanır ve erişilebilen bütün nesneler işaretlenir.
2. Sweep: Bellek taranır; işaretlenmemiş nesneler serbest bırakılır.

Basitleştirilmiş sözde kod şöyledir:

function collect(roots, heap):
    for root in roots:
        markRecursively(root)

    for object in heap:
        if object.marked:
            object.marked = false
        else:
            free(object)

markRecursively, nesnenin referans verdiği komşuları dolaşır. İşaretlerin temizlenmesi ise bir sonraki toplama turuna hazırlıktır. Mark-sweep döngüsel yapıları başarıyla toplar ve nesneleri taşımadığı için adreslerin sabit kalmasını sağlar. Buna karşılık tüm yığını taramak gecikmeye neden olabilir. Ayrıca boşalan alanlar dağınık kalır ve bellek parçalanması oluşabilir.

Nesil bazlı GC: Gençler hızlı yaşar

Nesil bazlı GC, deneysel bir gözleme dayanır: Yeni oluşturulan nesnelerin büyük bölümü kısa sürede ölür. Buna zayıf nesil hipotezi denir. Bellek genellikle genç, yaşlı ve bazen kalıcı bölgeler şeklinde ayrılır.

Bir nesnenin hayatta kalma olasılığı $p$ ise, art arda $k$ toplama turundan sağ çıkma olasılığı kabaca:

Genç bölgede sık fakat küçük çaplı minor GC çalışır. Birkaç tur hayatta kalan nesneler yaşlı bölgeye terfi ettirilir. Yaşlı bölge daha seyrek taranır; kapsamlı işlem çoğunlukla major veya full GC olarak adlandırılır.

Genç nesneleri tararken yaşlı bir nesnenin genç bir nesneye verdiği referans kaybolmamalıdır. Bu nedenle çalışma zamanı, referans güncellemelerini izleyen write barrier ve hatırlanan kümeler kullanır. Böylece her minor GC sırasında bütün yaşlı bölgeyi taramak gerekmez.

Yan yana karşılaştırma

Burada önemli bir nüans vardır: Nesil bazlı GC, mark-sweep’in mutlaka rakibi değildir. Modern çalışma zamanları genç bölgede kopyalamalı toplama, yaşlı bölgede ise mark-sweep veya mark-compact kullanabilir. Yani nesil yaklaşımı, nesnelerin nerede ve ne sıklıkta toplanacağını; mark-sweep ise nasıl tespit edilip temizleneceğini anlatır.

Hangisi ne zaman mantıklı?

Basitlik, sabit nesne adresleri veya sınırlı çalışma zamanı altyapısı önemliyse mark-sweep iyi bir başlangıçtır. Web sunucuları, sanal makineler ve yoğun şekilde geçici nesne oluşturan uygulamalar ise nesil bazlı GC’den ciddi fayda görür. Yine de gecikmeye duyarlı sistemlerde ortalama hız kadar en uzun duraklama da ölçülmelidir. Kısacası en iyi GC, yalnızca çöpleri bulan değil, programın çalışma karakterine en az sürprizle uyum sağlayandır.

Temel fikir: Aralığı üst sınıra dönüştürmek

Digit DP problemleri çoğunlukla şu fonksiyonla çözülür:

Böylece $[L,R]$ aralığının cevabı basitçe

olur. Bu dönüşüm önemlidir; çünkü yalnızca “$N$ sayısını aşmadan basamakları nasıl seçerim?” sorusuna odaklanmamızı sağlar.

Sayının basamaklarını soldan sağa gezerken genellikle aşağıdaki durumlar tutulur:

tight doğruysa mevcut basamak en fazla $N$’nin aynı konumdaki rakamı olabilir. Yanlışsa artık sınırdan küçük bir sayı oluşturduğumuz kesindir ve $0$ ile $9$ arasındaki tüm rakamları özgürce deneyebiliriz.

Neden klasik döngü yetmez?

Burada $d$, basamak sayısıdır. Digit DP aynı pos, tight ve problem durumuna tekrar ulaşıldığında sonucu önbellekten getirir. Böylece devasa sayı uzayı küçük bir durum grafiğine dönüşür.

Örnek: Rakamları toplamı hedefe eşit sayılar

Aşağıdaki Python kodu, $0$ ile $N$ arasında rakamları toplamı target olan sayıların adedini hesaplar:

from functools import lru_cache

def count_up_to(n, target):
    if n < 0:
        return 0

    digits = list(map(int, str(n)))

    @lru_cache(None)
    def dp(pos, total, tight):
        # Tüm basamaklar seçildiyse toplamı kontrol et.
        if pos == len(digits):
            return int(total == target)

        # Toplam hedefi geçtiyse devam etmek gereksizdir.
        if total > target:
            return 0

        limit = digits[pos] if tight else 9
        answer = 0

        for digit in range(limit + 1):
            next_tight = tight and (digit == limit)
            answer += dp(pos + 1, total + digit, next_tight)

        return answer

    return dp(0, 0, True)

def count_in_range(left, right, target):
    return count_up_to(right, target) - count_up_to(left - 1, target)

print(count_in_range(100, 10000, 10))

Fonksiyondaki baştaki sıfırlar sorun oluşturmaz: 0073, sayısal olarak 73’ü temsil eder ve rakam toplamı değişmez. Ancak “kaç basamaklı?”, “ilk rakam nedir?” veya “yan yana iki eşit rakam var mı?” gibi koşullarda started durumu eklenmelidir. Böylece henüz başlamamış sıfırlar gerçek basamaklarla karıştırılmaz.

Durumu doğru tasarlamak

Digit DP’nin zor kısmı kod değil, geçmişten hangi bilginin geleceği etkilediğini bulmaktır. Bölünebilirlik için remainder, yasaklı alt dize için otomat durumu, ardışık rakamlar için previous_digit tutulabilir. Örneğin yeni kalan

şeklinde güncellenir.

Her ayrıntıyı duruma eklemek belleği şişirir; eksik bilgi eklemek ise yanlış sonuç üretir. Altın kural şudur: Gelecekteki seçimlerin sonucunu etkileyen en küçük bilgiyi sakla. Bu denge kurulduğunda Digit DP, astronomik aralıkları birkaç bin durumla sayan oldukça güçlü ve şaşırtıcı derecede eğlenceli bir tekniğe dönüşür.

Maksimum akışın teorik temeli

Yönlü bir $G=(V,E)$ grafında her $(u,v)$ kenarı için bir $c(u,v)$ kapasitesi bulunur. Akış değeri $f(u,v)$ şu kısıtları sağlamalıdır:

Kaynak $s$ ve hedef $t$ dışındaki her düğümde akış korunur:

Başka bir deyişle, ara düğüme giren miktar oradan çıkmalıdır; düğüm gizlice su içemez! Amaç, $s$ düğümünden çıkan toplam akışı maksimize etmektir.

Algoritmalar bunu artık ağ üzerinden yapar. Bir kenardan akış gönderildiğinde ileri yöndeki kullanılabilir kapasite azalırken ters yönde aynı miktarda kapasite oluşur. Bu ters kenarlar, daha önce verilen kötü bir kararı geri alıp akışı farklı bir rotaya taşıyabilmemizi sağlar.

Dinic’in iki temel adımı

Dinic algoritması her turda iki işlem gerçekleştirir:

1. BFS ile katmanlı ağ kurar. Her düğüme kaynaktan olan kenar mesafesi atanır. Yalnızca level[v] = level[u] + 1 koşulunu sağlayan kenarlar kullanılır.
2. DFS ile bloklayan akış gönderir. Katmanlı ağda ilerletilebilecek akış kalmayıncaya kadar uygun yollar değerlendirilir.

Hedef BFS sonucunda erişilemez olduğunda artırma yolu kalmamıştır ve bulunan akış maksimumdur.

Dinic’in genel karmaşıklığı $O(V^2E)$ olsa da pratikte çoğu ağda oldukça hızlıdır. Birim kapasiteli özel graflarda daha güçlü sınırlar elde edilebilir.

C++ ile uygulama

Aşağıdaki uygulamada her gerçek kenarla birlikte kapasitesi başlangıçta sıfır olan ters kenar eklenir. work dizisi, DFS’nin sonuç vermeyen kenarları tekrar tekrar incelemesini önler.

#include <bits/stdc++.h>
using namespace std;

struct Edge {
    int to, rev;
    long long cap;
};

class Dinic {
    vector<vector<Edge>> graph;
    vector<int> level, work;

    bool bfs(int source, int sink) {
        fill(level.begin(), level.end(), -1);
        queue<int> q;
        level[source] = 0;
        q.push(source);

        while (!q.empty()) {
            int u = q.front(); q.pop();
            for (const Edge& e : graph[u]) {
                if (e.cap > 0 && level[e.to] == -1) {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return level[sink] != -1;
    }

    long long dfs(int u, int sink, long long flow) {
        if (u == sink) return flow;

        for (int& i = work[u]; i < (int)graph[u].size(); ++i) {
            Edge& e = graph[u][i];
            if (e.cap <= 0 || level[e.to] != level[u] + 1) continue;

            long long sent = dfs(e.to, sink, min(flow, e.cap));
            if (sent > 0) {
                e.cap -= sent;
                graph[e.to][e.rev].cap += sent;
                return sent;
            }
        }
        return 0;
    }

public:
    explicit Dinic(int n) : graph(n), level(n), work(n) {}

    void addEdge(int from, int to, long long capacity) {
        Edge forward{to, (int)graph[to].size(), capacity};
        Edge reverse{from, (int)graph[from].size(), 0};
        graph[from].push_back(forward);
        graph[to].push_back(reverse);
    }

    long long maxFlow(int source, int sink) {
        long long total = 0, sent;
        const long long INF = numeric_limits<long long>::max();

        while (bfs(source, sink)) {
            fill(work.begin(), work.end(), 0);
            while ((sent = dfs(source, sink, INF)) > 0)
                total += sent;
        }
        return total;
    }
};

Neden katmanlar hız kazandırır?

Sıradan artırma yaklaşımı aynı bölgelerde dolaşabilir. Katmanlı ağ ise DFS’yi yalnızca hedefe doğru ilerleyen kenarlarla sınırlar. Bir BFS turunda bulunan bloklayan akış, en az bir kritik geçişi tamamen doldurur. Sonraki turda hedefe olan katman mesafesi artar; bu mesafe en fazla $V-1$ olabileceğinden BFS turlarının sayısı da sınırlıdır.

Dinic; ağ yönlendirme, bipartite eşleme, görev atama ve kapasite planlama problemlerinde güçlü bir seçimdir. Özellikle graf büyük, fakat bağlantılar nispeten seyrekse katmanlama ile gereksiz aramaların azaltılması belirgin bir performans avantajı sağlar.

Kararlı eşleştirme nedir?

Problemde genellikle eşit büyüklükte iki küme bulunur: $A$ ve $B$. Her katılımcı, karşı kümedeki kişileri en çok tercih edilenden en aza doğru sıralar. Amaç, her elemanın tam bir kişiyle eşleştirildiği bir sonuç üretmektir.

Bir eşleştirmede $a \in A$ ve $b \in B$, mevcut eşlerinden daha çok birbirlerini tercih ediyorsa bu ikiliye engelleyici çift denir. Kararlı eşleştirmede böyle bir çift bulunmaz.

Burada $M(a)$, $a$ katılımcısının mevcut eşini; $\succ_a$ ise $a$ açısından “daha çok tercih edilir” ilişkisini gösterir.

Algoritma nasıl çalışır?

Gale-Shapley, ertelenmiş kabul yaklaşımını kullanır. $A$ tarafının teklif verdiğini düşünelim:

1. Eşi olmayan bir $A$ katılımcısı, henüz teklif etmediği en yüksek tercihine gider.
2. Teklifi alan $B$ katılımcısı boşsa teklifi geçici olarak kabul eder.
3. Zaten bir teklifi tutuyorsa iki adayı karşılaştırır; daha çok tercih ettiğini tutup diğerini reddeder.
4. Reddedilen kişi sıradaki tercihine teklif verir.
5. Eşleşmemiş teklif sahibi kalmayana kadar süreç devam eder.

“Geçici kabul” kritik ayrıntıdır. Bir katılımcı iyi bir teklifi tutabilir, ancak daha iyisi gelirse fikrini değiştirebilir. Romantik komedi gibi görünse de süreç kesinlikle sona erer: Her teklif sahibi karşı taraftaki herkese en fazla bir kez teklif eder. $n$ kişilik iki grup için en fazla $n^2$ teklif yapılır; dolayısıyla zaman karmaşıklığı $O(n^2)$ olur.

Python ile uygulama

Aşağıdaki kod, teklif alanların tercih sıralarını sözlük biçiminde önceden hesaplar. Böylece iki adayı karşılaştırmak $O(1)$ zamanda gerçekleştirilebilir.

def gale_shapley(proposers, receivers):
    free = list(proposers)
    next_choice = {p: 0 for p in proposers}
    engaged = {}

    # Küçük sıra değeri, daha yüksek tercih anlamına gelir.
    rank = {
        r: {p: i for i, p in enumerate(order)}
        for r, order in receivers.items()
    }

    while free:
        p = free.pop(0)
        r = proposers[p][next_choice[p]]
        next_choice[p] += 1

        if r not in engaged:
            engaged[r] = p
        else:
            current = engaged[r]
            if rank[r][p] < rank[r][current]:
                engaged[r] = p
                free.append(current)
            else:
                free.append(p)

    return {p: r for r, p in engaged.items()}

students = {
    "Ada": ["X", "Y", "Z"],
    "Bora": ["Y", "X", "Z"],
    "Cem": ["Y", "Z", "X"]
}

schools = {
    "X": ["Bora", "Ada", "Cem"],
    "Y": ["Ada", "Cem", "Bora"],
    "Z": ["Cem", "Bora", "Ada"]
}

print(gale_shapley(students, schools))

Neden sonuç garanti edilir?

Algoritma sonlandığında reddedilmiş bir teklif sahibi, onu reddeden kişinin mevcut veya daha çok tercih ettiği bir adayı tuttuğunu bilir. Bu nedenle sonradan engelleyici çift oluşturamaz. Ayrıca teklifler sonlu olduğu için algoritma sonsuz döngüye girmez.

Önemli bir nüans vardır: Kararlı sonuç her zaman herkes için eşit derecede iyi değildir. Teklif yapan taraf, tüm kararlı eşleştirmeler arasındaki kendisi için en iyi sonucu alırken diğer taraf açısından sonuç daha az avantajlı olabilir. Tercihlerde eşitlikler, eksik listeler veya farklı kapasiteler bulunduğunda model genişletilmelidir. Yine de temel fikir değişmez: Yerel tercihler dikkatlice yönetildiğinde küresel bir kararlılık elde edilebilir.

``

Temel fikir: İfadeler kısıt üretir

HM sisteminde her ifadeye başlangıçta bilinmeyen bir tip değişkeni atanabilir. Bu değişkenler genellikle $\alpha$, $\beta$ ve $\gamma$ ile gösterilir. Ardından programın yapısı incelenerek tip denklemleri oluşturulur.

Örneğin şu fonksiyonu ele alalım:

f x = x

x için $\alpha$ tipini seçersek fonksiyon aynı tipte bir değer döndürür. Dolayısıyla:

Buradaki $\alpha$, belirli bir tip değildir. Int, String veya başka herhangi bir tip olabilir. Bu nedenle f, polimorfik bir fonksiyondur.

Bir fonksiyon uygulamasında ise kural şöyledir: f x ifadesinin tipi $\beta$ ise f fonksiyonunun tipi mutlaka

biçiminde olmalıdır. Tip çıkarımı, program boyunca bu tür denklemleri toplar ve çözer.

Birleştirme: Tip bulmacasının motoru

Denklemleri çözme işlemine unification, yani birleştirme denir. Amaç, iki tipi eşit hâle getiren yer değiştirmeleri bulmaktır.

Birleştirme sırasında önemli bir güvenlik kontrolü de occurs check işlemidir. Örneğin $\alpha = \alpha \to \beta$ eşitliğine izin verilirse sonsuz bir tip oluşur. HM bunu reddeder; matematiksel canavarların programa sızmasına müsaade etmez.

Algorithm W nasıl çalışır?

HM tip çıkarımının klasik uygulaması Algorithm W olarak bilinir. Algoritma, sözdizimi ağacını dolaşırken hem bir tip hem de bulunan tip eşitliklerini temsil eden bir substitution üretir.

Aşağıdaki sadeleştirilmiş Python kodu, fonksiyon uygulamasının mantığını gösterir:

def infer_application(env, function, argument):
    # Fonksiyonun ve argümanın tiplerini ayrı ayrı çıkar.
    s1, function_type = infer(env, function)
    s2, argument_type = infer(apply_env(s1, env), argument)

    # Uygulamanın henüz bilinmeyen sonuç tipi.
    result_type = fresh_type_variable()

    # Fonksiyon tipi, argüman -> sonuç biçimiyle eşleşmelidir.
    s3 = unify(
        apply_type(s2, function_type),
        FunctionType(argument_type, result_type)
    )

    substitution = compose(s3, compose(s2, s1))
    return substitution, apply_type(s3, result_type)

Burada fresh_type_variable yeni bir tip değişkeni oluşturur. unify gerekli eşleştirmeleri bulur, compose ise farklı aşamalarda bulunan sonuçları birleştirir. Böylece çıkarım yerel tahminlerden tutarlı bir genel sonuca ilerler.

Let-polimorfizmi neden önemlidir?

HM sisteminin güçlü taraflarından biri let ile tanımlanan değerleri genelleştirmesidir:

let identity = \x -> x
in (identity 42, identity "merhaba")

identity yalnızca tek bir bilinmeyen tipe sabitlenmez. Tipi $\forall \alpha.\alpha \to \alpha$ olarak genelleştirilir ve her kullanımda yeni değişkenlerle örneklenir. Böylece aynı fonksiyon hem sayı hem metin üzerinde güvenle kullanılabilir.

HM kusursuz değildir; alt tipleme, gelişmiş nesne modelleri ve bazı yan etkiler sistemi karmaşıklaştırır. Yine de ML, OCaml ve Haskell gibi dillerin temelinde yer alarak önemli bir denge kurar: geliştirici az tip yazar, derleyici çok düşünür ve hatalı programlar üretime çıkmadan kapıda yakalanır.

İki yarışma, iki farklı problem kültürü

International Olympiad in Informatics (IOI), lise öğrencilerine yönelik bireysel bir yarışmadır. Sorular çoğunlukla alt görevler ve kısmi puanlama içerir. Bu nedenle önce yavaş ama doğru bir çözüm kurup ardından onu aşamalı biçimde hızlandırmak mümkündür.

International Collegiate Programming Contest (ICPC) ise üç kişilik üniversite takımlarının süreye karşı yarıştığı bir formattır. Burada problem seçimi, hatasız uygulama ve takım koordinasyonu da algoritma bilgisi kadar önemlidir.

IOI 2000: Post Office

Post Office, doğrusal bir yol üzerindeki köylere belirli sayıda postane yerleştirme problemidir. Amaç, her köyün en yakın postaneye uzaklıkları toplamını küçültmektir. Tek bir postanenin hizmet verdiği sıralı köy grubu için en iyi konum medyandır.

Köy konumları $x_l,\ldots,x_r$ ise grubun maliyeti

şeklindedir; burada $m=\lfloor(l+r)/2\rfloor$ seçilebilir. Ardından bölümlemeli dinamik programlama gelir:

Bu soru klasikleşmiştir çünkü üç önemli fikri kusursuz biçimde birleştirir: sıralama, medyanın mutlak uzaklık için optimal oluşu ve aralıkları dinamik programlamayla bölme.

for (int k = 1; k <= postaneSayisi; ++k) {
    for (int i = 1; i <= koySayisi; ++i) {
        for (int j = 0; j < i; ++j) {
            dp[k][i] = min(dp[k][i], dp[k - 1][j] + maliyet[j + 1][i]);
        }
    }
}

Bu çekirdek kod, ilk i köyü k postaneyle kapsamak için son grubun nerede başladığını dener. Asıl ustalık, maliyet[l][r] değerlerini önceden hesaplayarak geçişi ucuzlatmaktır.

IOI 2011: Race

Race, ağırlıklı bir ağaçta toplam uzunluğu tam $K$ olan ve mümkün olan en az kenarı kullanan yolu arar. İlk bakışta bütün düğüm çiftlerini denemek doğal görünür; fakat bu yaklaşık $O(N^2)$ yol anlamına gelir.

Klasik çözüm centroid decomposition kullanır. Ağaç dengeli parçalara ayrılır; centroid’den alt ağaçlara olan uzaklıklar toplanır ve daha önce görülen $K-d$ uzaklığı aranır. Böylece çalışma süresi kabaca $O(N\log N)$ seviyesine iner. Problem, centroid decomposition tekniğini yalnızca sergilemediği, neden gerekli olduğunu hissettirdiği için efsanedir.

ICPC klasiği: Tower of Cubes

1997 Dünya Finalleri ile özdeşleşen Tower of Cubes, renkli yüzlere sahip küpleri üst üste dizerken temas eden renklerin eşleşmesini ister. Hikâye fiziksel görünse de yapı, yönlendirilmiş en uzun yol problemine dönüşür. Her küpün altı olası yönelimi birer durumdur; bir yönelimden diğerine geçiş, üst ve alt renklerin uyuşmasına bağlıdır.

Peki bir problem neden klasikleşir?

Klasik bir problem genellikle kısa anlatılır, birden fazla makul fakat yetersiz çözüm sunar ve çözüm bulunduğunda “Bunu nasıl göremedim?” duygusu yaratır. Dahası, kullanılan fikir başka problemlere taşınabilir: Post Office medyanı ve bölümlemeyi, Race dengeli ağaç ayrıştırmayı, Tower of Cubes ise hikâyeyi durum grafiğine çevirmeyi öğretir.

Efsane sorular geçmişin zor bilmeceleri değildir; algoritmik düşüncenin laboratuvarlarıdır. Onları çözerken yalnızca kabul işareti kazanmaz, bir sonraki bilinmeyen probleme bakmak için yeni bir gözlük edinirsiniz.

Derleme ile yorumlama arasındaki köprü

Bir işlemci Java, C# veya JavaScript gibi yüksek seviyeli dilleri doğrudan anlayamaz; yalnızca kendi komut setine uygun makine kodunu çalıştırır. Bu dönüşüm için üç temel yaklaşım bulunur:

JIT kullanan sistemler genellikle kaynak kodu önce bytecode veya benzeri bir ara temsile dönüştürür. Sanal makine başlangıçta bu ara kodu yorumlayabilir. Aynı fonksiyon tekrar tekrar çağrıldığında sistem, “Bu bölge sıcak!” diyerek onu yerel makine koduna derler.

Sıcak kod nasıl belirlenir?

Çalışma zamanı; metot çağrılarını, döngü tekrarlarını ve kullanılan veri türlerini sayaçlarla takip eder. Bir kod parçasının çağrı sayısını $n$, yorumlama maliyetini $I$, derleme maliyetini $C$ ve derlenmiş çalışma maliyetini $M$ olarak düşünelim. JIT derlemenin kazançlı olması için yaklaşık olarak şu koşul aranır:

Başka bir ifadeyle, gelecekte sağlanacak hız kazancı derleme masrafını aşmalıdır. Yalnızca bir kez çalışan başlangıç kodunu derlemek çoğu zaman gereksizdir. Fakat milyonlarca kez dönen küçük bir hesaplama fonksiyonu oldukça değerli bir hedeftir.

static long karelerToplami(int limit) {
    long toplam = 0;
    for (int i = 0; i < limit; i++) {
        toplam += (long) i * i;
    }
    return toplam;
}

Bu metot sık çağrılırsa JIT, yalnızca makine kodu üretmekle kalmaz; döngüyü açabilir, gereksiz kontrolleri kaldırabilir veya işlemcinin vektör komutlarından yararlanabilir. Böylece aynı sonuç daha az komutla hesaplanır.

JIT’in gizli silahı: spekülatif optimizasyon

AOT derleyici, programın gelecekte hangi türlerle karşılaşacağını kesin olarak bilemez. JIT ise gerçek çalışma verisini görür. Örneğin JavaScript’te aşağıdaki fonksiyon başlangıçta her tür değeri kabul edebilir:

function topla(a, b) {
  return a + b;
}

for (let i = 0; i < 1_000_000; i++) {
  topla(i, i + 1);
}

Motor, a ve b değerlerinin sürekli tam sayı olduğunu gözlemlerse genel amaçlı toplama yerine hızlı bir tamsayı komutu üretebilir. Buna spekülatif optimizasyon denir: sistem, gözlenen düzenin devam edeceğini varsayar.

Peki daha sonra topla("merhaba", " dünya") çağrılırsa ne olur? Varsayım bozulur ve motor deoptimizasyon yaparak daha genel koda geri döner. JIT hızlıdır ama falcı değildir; tahminlerini gerektiğinde iptal eder.

Isınma neden önemlidir?

İlk çağrılar sırasında profil oluşturma ve derleme maliyeti bulunduğundan performans testlerinde “warm-up” aşaması kullanılır. Aksi hâlde ölçüm, uygulamanın kararlı hızından çok başlangıç masraflarını gösterir.

JIT’in çalışma döngüsü kısaca şöyledir:

1. Ara kodu yorumlayarak hızlıca başla.
2. Çalışma davranışını profille.
3. Sıcak bölgeleri makine koduna derle.
4. Gözlenen türlere göre agresif optimizasyon uygula.
5. Varsayımlar bozulursa güvenli sürüme geri dön.

Sonuç olarak kod aslında kendi kendine öğrenmez; çalışma zamanı sistemi onu gözlemler ve kaynaklarını en çok kullanılan bölgelere yatırır. Program “ısındıkça” hızlanmasının nedeni de tam olarak budur.

CHT hangi bağıntılarda kullanılabilir?

Şu klasik DP geçişini ele alalım:

Sabit bir $i$ için $x[i]$ bellidir. Her $j$ seçeneği ise

biçiminde bir doğru oluşturur. Burada $m_j=a[j]$ eğim, $c_j=dp[j]+b[j]$ sabit terimdir. Dolayısıyla $dp[i]$, bütün doğruların $x[i]$ noktasındaki minimum değeridir.

Naif çözüm her $i$ için tüm eski doğruları dener. CHT ise yalnızca gelecekte gerçekten en iyi olabilecek doğruları saklar. Bir doğru hiçbir $x$ değerinde minimum olamıyorsa zarftan çıkarılır; geometrik olarak alt konveks zarf korunur.

Bir doğru ne zaman gereksizdir?

Eğimleri sıralı üç doğru düşünelim: $L_1$, $L_2$ ve $L_3$. Eğer $L_1$ ile $L_2$ kesişimi, $L_2$ ile $L_3$ kesişiminin sağında kalıyorsa $L_2$ hiçbir zaman en iyi seçenek olamaz. Bölme işlemi ve kayan nokta hatalarından kaçınmak için kesişimleri çapraz çarparak karşılaştırabiliriz.

Doğruların eğimleri monoton ekleniyor ve sorgu değerleri $x$ de monoton geliyorsa bir deque yeterlidir. Ön taraftaki doğru, sıradaki doğrudan kötü olduğunda silinir. Böylece her doğru en fazla bir kez eklenir ve bir kez çıkarılır.

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct Line {
    ll m, b;
    ll value(ll x) const { return m * x + b; }
};

// Orta doğru, alt zarf üzerinde gereksiz mi?
bool redundant(const Line& a, const Line& b, const Line& c) {
    return (__int128)(b.b - a.b) * (b.m - c.m)
         >= (__int128)(c.b - b.b) * (a.m - b.m);
}

struct MonotoneCHT {
    deque<Line> hull;

    // Eğimlerin azalan sırada geldiği varsayılıyor.
    void add(ll m, ll b) {
        Line line{m, b};
        while (hull.size() >= 2 &&
               redundant(hull[hull.size() - 2], hull.back(), line))
            hull.pop_back();
        hull.push_back(line);
    }

    // x değerlerinin artan sırada sorgulandığı varsayılıyor.
    ll query(ll x) {
        while (hull.size() >= 2 &&
               hull[0].value(x) >= hull[1].value(x))
            hull.pop_front();
        return hull.front().value(x);
    }
};

__int128, çarpımların long long sınırını aşma riskini azaltır. Ancak doğru değerlerinin kendisi de taşabilecekse value fonksiyonunda aynı tür kullanılmalıdır.

Monotonluk yoksa ne olacak?

Eğimler veya sorgular sıralı değilse deque sürümü güvenli değildir. Bu durumda iki yaygın seçenek vardır:

Li Chao ağacı, belirli bir $x$ aralığında doğruları segment ağacına benzer biçimde tutar. Biraz daha fazla bellek kullanır ama monotonluk şartlarını ortadan kaldırır.

CHT uygularken önce bağıntıdaki $j$ kaynaklı ifadeleri eğim ve sabit terime, $i$ kaynaklı ifadeyi ise sorgu koordinatına ayır. Ardından minimum mu maksimum mu aradığını, eşit eğimlerin nasıl yönetileceğini ve sayı taşmalarını kontrol et. Doğru cebir yapıldığında konveks zarf hilesi, ürkütücü görünen karesel DP’leri oldukça zarif algoritmalara dönüştürür.

``

Temel fikir

Elimizde $A$ ve $B$ adında iki küme bulunsun. Bunları birleştirirken hangi kümenin hedef olacağı sonucu değiştirmez; fakat çalışma süresini ciddi biçimde etkiler.

• $\vert A\vert < \vert B\vert $ ise $A$ içindeki elemanları $B$’ye taşı.
• $\vert B\vert < \vert A\vert $ ise $B$ içindeki elemanları $A$’ya taşı.
• Büyük koleksiyon yerinde kalırken yalnızca küçük koleksiyon dolaşılır.

Tekniğin sırrı, taşınan bir elemanın bulunduğu koleksiyonun büyüklüğünün her taşımadan sonra en az iki katına çıkmasıdır. Bir eleman sırasıyla büyüklüğü $1, 2, 4, 8, \ldots$ olan koleksiyonlara geçebilir. Toplam eleman sayısı $n$ olduğuna göre:

Dolayısıyla her eleman en fazla $O(\log n)$ kez taşınır. Ekleme işlemi sabit maliyetliyse toplam maliyet $O(n\log n)$ olur.

Ağaçlarda kullanım

Yaygın bir problem, köklü bir ağaçta her düğümün alt ağacında kaç farklı renk bulunduğunu hesaplamaktır. Her düğüm için sıfırdan tarama yapmak pahalıdır. Bunun yerine çocuklardan gelen renk kümeleri küçükten büyüğe birleştirilebilir.

#include <iostream>
#include <vector>
#include <set>
using namespace std;

vector<vector<int>> graph;
vector<int> color, answer;

set<int>* dfs(int node, int parent) {
    // Başlangıçta küme yalnızca düğümün kendi rengini içerir.
    set<int>* bag = new set<int>();
    bag->insert(color[node]);

    for (int child : graph[node]) {
        if (child == parent) continue;

        set<int>* childBag = dfs(child, node);

        // Her zaman küçük kümeyi büyük kümeye ekleyeceğiz.
        if (bag->size() < childBag->size()) {
            swap(bag, childBag);
        }

        for (int value : *childBag) {
            bag->insert(value);
        }

        delete childBag;
    }

    answer[node] = static_cast<int>(bag->size());
    return bag;
}

Burada dfs, her alt ağaç için bir renk kümesi döndürür. swap işlemi koleksiyonları kopyalamaz; yalnızca işaretçileri değiştirir. Böylece büyük küme hedef olarak korunur. std::set eklemesi $O(\log n)$ sürdüğü için genel üst sınır $O(n\log^2 n)$ olur. Uygun bir unordered_set kullanılırsa beklenen süre $O(n\log n)$ seviyesine yaklaşabilir; ancak hash çakışmaları ve yeniden boyutlandırma maliyetleri unutulmamalıdır.

Nerelerde işe yarar?

Teknik yalnızca renk kümeleriyle sınırlı değildir. Alt ağaç frekanslarını birleştirme, bağlı bileşenlere veri ekleme, sorguları çevrim dışı işleme ve harita tabanlı sayaçları toplama gibi durumlarda kullanılabilir. DSU birleştirmesinde kullanılan union by size yaklaşımı da aynı düşünce ailesindendir: küçük bileşen büyük bileşene bağlanır.

Dikkat edilmesi gereken nokta, birleştirme yönünün gerçekten boyuta göre seçilmesidir. Ayrıca koleksiyon kopyalamak yerine referans, işaretçi veya taşıma semantiği kullanılmalıdır. Aksi hâlde kazandığımız karmaşıklığı gizli kopyalama maliyetleriyle geri verebiliriz.

Özetle small-to-large, “daha az veriyi hareket ettir” ilkesinin algoritmik hâlidir. Uygulaması birkaç satırlık bir karşılaştırma ve takastan ibaret olsa da karesel çalışan çözümleri çoğu zaman logaritmik amortismanla çok daha ölçeklenebilir hâle getirir.

``

Lambda calculus nedir?

Lambda calculus, Alonzo Church tarafından hesaplanabilirliği incelemek amacıyla geliştirilen küçük fakat güçlü bir biçimsel sistemdir. Yalnızca üç temel yapıdan oluşur:

1. Değişken: $x$
2. Fonksiyon tanımı: $\lambda x.M$
3. Fonksiyon uygulaması: $M\ N$

Örneğin kendisine verilen değeri değiştirmeden döndüren özdeşlik fonksiyonu şöyledir:

Bu fonksiyona $5$ uygularsak ifade $(\lambda x.x)\ 5$ olur ve sonuç $5$ çıkar. Burada gerçekleşen işleme beta indirgeme denir:

Sözel olarak: Fonksiyon gövdesindeki $x$ değişkenlerini, verilen $N$ değeriyle değiştir. Yani beta indirgeme, matematik dünyasının fonksiyon çağrısıdır.

Matematikten koda geçiş

Lambda ifadelerinin modern dillerdeki karşılıkları şaşırtıcı derecede açıktır:

JavaScript ile iki sayıyı toplayan curried bir fonksiyon yazalım:

const topla = x => y => x + y;

const onaEkle = topla(10);
console.log(onaEkle(7)); // 17

topla(10) çağrısı hemen bir sayı üretmez; x değerini hatırlayan yeni bir fonksiyon döndürür. onaEkle, dış kapsamındaki 10 değerini koruduğu için bir closure örneğidir. Lambda calculus açısından ifade şöyledir:

Birden fazla parametre alıyor gibi görünen fonksiyonların tek parametreli fonksiyon zincirine dönüştürülmesine currying denir.

Sayılar bile fonksiyon olabilir

Saf lambda calculus içinde sayı sabitleri yoktur. Buna rağmen sayılar, fonksiyonların kaç kez uygulanacağını belirten yapılarla temsil edilebilir. Bunlara Church sayıları adı verilir:

İki sayısı, f fonksiyonunu başlangıç değerine iki defa uygular. Python’da bu fikri çalıştırabiliriz:

church_iki = lambda f: lambda x: f(f(x))
artir = lambda n: n + 1

sonuc = church_iki(artir)(0)
print(sonuc)  # 2

Bu kod günlük kullanım için pratik değildir; ancak veri ile davranış arasındaki sınırın düşündüğümüz kadar keskin olmadığını gösterir. Yeterince güçlü fonksiyonlarla sayıları, mantıksal değerleri ve veri yapılarını modellemek mümkündür.

Saf fonksiyonların önemi

Lambda calculus, durum değiştirmek yerine ifadeleri dönüştürür. Bu yaklaşım modern fonksiyonel programlamadaki saf fonksiyon kavramını besler.

Örneğin kare(x) = x² saf bir fonksiyondur. Buna karşılık global bir sayacı artıran fonksiyon, yalnızca çıktı üretmez; sistemin durumunu da değiştirir.

Lambda calculus bize programlamanın özünde komut listelerinden ibaret olmadığını anlatır. Bir program, ifadelerin başka ifadelere dönüştürülmesi olarak da görülebilir. Bugün map, filter, anonim fonksiyonlar, higher-order functions ve closure kullanıyorsak Church’ün soyut matematik dünyası hâlâ klavyemizin hemen altındadır.