``

2-SAT nedir?

2-SAT formülleri, her parantezinde en fazla iki literal bulunan ve bağlaçlarla birleştirilen ifadelerdir:

Literal, bir değişkenin kendisi ($x$) veya değili ($\neg x$) olabilir. Genel bir madde $(a \lor b)$ biçimindedir. Bu ifade yalnızca $a$ ve $b$ birlikte yanlış olduğunda bozulur. Dolayısıyla şu iki zorunluluğu türetebiliriz:

Her zorunluluğu yönlü bir kenara dönüştürürsek implikasyon grafiği ortaya çıkar.

SCC neden çözümü belirliyor?

Bir güçlü bağlı bileşende, her düğümden diğer bütün düğümlere ulaşılabilir. Eğer $x$ ile $\neg x$ aynı SCC içindeyse hem $x \Rightarrow \neg x$ hem de $\neg x \Rightarrow x$ geçerlidir. Hangi doğruluk değerini seçersek seçelim sistem tersini de zorlar; formül çözülemez.

Böylece temel ölçüt şudur:

Bu, yönlü döngülerin mantıksal çelişkiyi görünür hâle getirmesidir. SCC’ler Tarjan veya Kosaraju algoritmasıyla $O(V+E)$ zamanda bulunur. $n$ değişken ve $m$ madde için grafikte $2n$ düğüm, $2m$ kenar bulunduğundan toplam karmaşıklık $O(n+m)$ olur.

Kosaraju ile uygulama

Aşağıdaki C++ kodu, pozitif literali 2*x, negatifini 2*x+1 ile temsil eder. p^1 işlemi bir literalden karşıtına geçer. İlk DFS bitiş sırasını, ikinci DFS ise ters grafikte bileşenleri üretir.

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

struct TwoSAT {
    int n;
    vector<vector<int>> g, rg;
    vector<int> order, comp, used;

    TwoSAT(int n) : n(n), g(2*n), rg(2*n),
                    comp(2*n, -1), used(2*n) {}

    // (a OR b) maddesini implikasyon grafiğine ekler.
    void addClause(int a, int b) {
        g[a ^ 1].push_back(b);
        rg[b].push_back(a ^ 1);
        g[b ^ 1].push_back(a);
        rg[a].push_back(b ^ 1);
    }

    void dfs1(int v) {
        used[v] = 1;
        for (int u : g[v]) if (!used[u]) dfs1(u);
        order.push_back(v);
    }

    void dfs2(int v, int id) {
        comp[v] = id;
        for (int u : rg[v]) if (comp[u] == -1) dfs2(u, id);
    }

    bool solve(vector<bool>& value) {
        for (int v = 0; v < 2*n; ++v)
            if (!used[v]) dfs1(v);

        reverse(order.begin(), order.end());
        int id = 0;
        for (int v : order)
            if (comp[v] == -1) dfs2(v, id++);

        value.resize(n);
        for (int x = 0; x < n; ++x) {
            if (comp[2*x] == comp[2*x+1]) return false;
            value[x] = comp[2*x] > comp[2*x+1];
        }
        return true;
    }
};

solve, çelişki yoksa örnek bir doğruluk ataması da üretir. Bileşen numaralarına göre yapılan karşılaştırma, SCC’lerin yoğunlaştırılmış grafiğindeki ters topolojik sıradan yararlanır.

Sonuç olarak 2-SAT’ın gücü, mantığı kaba kuvvetle çözmek yerine onu erişilebilirlik problemine dönüştürmesinden gelir. Bir değişken kendi değiliyle aynı yönlü döngünün içine hapsolmuşsa çelişki kaçınılmazdır; aksi durumda bileşen sırası tutarlı bir atamayı doğrudan verir.

``

Fenwick Ağacının temel fikri

Tek boyutlu BIT, her indeksin belirli uzunluktaki bir aralığın toplamını saklamasına dayanır. Bir indeksin sorumlu olduğu aralık, ikili gösterimindeki en düşük anlamlı bit ile belirlenir:

Örneğin $12=(1100)_2$ için $lowbit(12)=4$ olur. Güncelleme sırasında indeksleri $lowbit(i)$ kadar artırır, önek toplamında ise aynı miktarı çıkarırız. Böylece her işlem en fazla $O(\log n)$ düğüme dokunur.

İki boyutta aynı düşünceyi satır ve sütun eksenlerine ayrı ayrı uygularız. $(x,y)$ noktasına eklenen değer, iki iç içe Fenwick yürüyüşüyle ilgili hücrelere taşınır. Bir dikdörtgen toplamı ise dahil etme–hariç tutma ilkesiyle bulunur:

Burada $P(x,y)$, $(1,1)$ ile $(x,y)$ arasındaki önek toplamıdır.

Segment ağacı mı, Fenwick mi?

BIT’in önemli sınırlaması, işlemin tersinin bulunabilmesidir. Toplamada çıkarma sayesinde iki önekten aralık üretilebilir. Ancak genel minimum sorgusunda “önek minimumlarını çıkarma” diye bir işlem yoktur. Bu durumda segment ağacı daha doğru seçimdir.

Bellek dostu 2B uygulama

Aşağıdaki C++ sınıfı matrisi satır satır tek bir vector içinde tutar. Ayrı ayrı vektörler oluşturmadığı için tahsis maliyetini azaltır ve önbellek yerelliğini iyileştirir.

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

class Fenwick2D {
    int n, m;
    vector<long long> bit;

    long long& at(int x, int y) {
        return bit[x * (m + 1) + y];
    }

public:
    Fenwick2D(int rows, int cols)
        : n(rows), m(cols), bit((rows + 1) * (cols + 1), 0) {}

    // (x, y) noktasına delta ekler.
    void add(int x, int y, long long delta) {
        for (int i = x; i <= n; i += i & -i)
            for (int j = y; j <= m; j += j & -j)
                at(i, j) += delta;
    }

    // (1,1) ile (x,y) arasındaki toplamı döndürür.
    long long prefix(int x, int y) {
        long long result = 0;
        for (int i = x; i > 0; i -= i & -i)
            for (int j = y; j > 0; j -= j & -j)
                result += at(i, j);
        return result;
    }

    long long rectangle(int x1, int y1, int x2, int y2) {
        return prefix(x2, y2) - prefix(x1 - 1, y2)
             - prefix(x2, y1 - 1) + prefix(x1 - 1, y1 - 1);
    }
};

İndekslerin 1’den başlaması önemlidir; sıfır için lowbit(0) sıfırdır ve güncelleme döngüsü ilerlemez.

Boyutlar devasa olduğunda

Koordinatlar milyarlara ulaşıyor fakat yalnızca birkaç bin nokta kullanılıyorsa tam matris ayırmak anlamsızdır. Güncelleme ve sorgulardaki koordinatları sıralayıp benzersizleştirerek koordinat sıkıştırma uygulanabilir. Her gerçek koordinat, sıralamadaki 1 tabanlı sırasına dönüştürülür.

$d$ boyutta güncelleme ve sorgu maliyeti yaklaşık $O(\log^d n)$ olur. Buna karşılık yoğun depolama $O(n^d)$ büyüdüğünden, pratikte üç ve üzeri boyutlarda yalnızca erişilen Fenwick hücrelerini karma tablo veya sıkıştırılmış iç vektörlerle saklamak gerekir. Kısacası toplam ve frekans sorgularında BIT, küçük kodu ve düşük sabit maliyetiyle güçlüdür; karmaşık birleştirme işlemlerinde ise segment ağacı hâlâ sahnededir.

``

Uzun çarpma neden yavaş?

İki sayının da $N$ basamaklı olduğunu düşünelim. Geleneksel yöntemde birinci sayının her basamağı, ikinci sayının her basamağıyla çarpılır. Dolayısıyla yaklaşık $N^2$ işlem gerekir:

Basamak sayısı iki katına çıktığında çalışma miktarı yaklaşık dört katına çıkar. FFT tabanlı yaklaşımda ise büyüme çok daha sakindir:

Sayıları polinoma dönüştürmek

Örneğin $1234$ sayısını şu polinomla temsil edebiliriz:

Burada $x=10$ seçildiğinde yeniden 1234 elde edilir. İki sayıyı çarpmak, bunlara karşılık gelen polinomları çarpmaya eşdeğerdir. Polinom çarpımındaki katsayılar ise ayrık konvolüsyonla bulunur:

Bu formül doğrudan uygulanırsa yine $O(N^2)$ zaman harcar. FFT’nin sihri, konvolüsyonu noktasal çarpıma dönüştürmesidir:

Yani önce katsayıları frekans uzayına taşır, karşılık gelen değerleri tek tek çarpar ve ters FFT ile geri döneriz.

Birim kökler ve böl-parçala-yönet

Ayrık Fourier Dönüşümü şu şekilde tanımlanır:

Üstel ifadeler, karmaşık düzlemde eşit aralıklarla yerleşmiş $N$’inci birim köklerdir. FFT, çift ve tek indeksli katsayıları ayırarak aynı hesaplamaları tekrar yapmaktan kurtulur. Her seviyede toplam $O(N)$ iş yapılır ve yaklaşık $\log_2N$ seviye bulunur.

Python ile sade bir uygulama

Aşağıdaki örnek, sayıları onluk basamaklarına ayırır. NumPy FFT hesaplamasını yapar; son döngü ise yuvarlama ve elde taşıma işlemlerini düzeltir.

import numpy as np

def fft_multiply(x: str, y: str) -> str:
    a = np.array([int(d) for d in x[::-1]], dtype=float)
    b = np.array([int(d) for d in y[::-1]], dtype=float)

    size = 1
    while size < len(a) + len(b):
        size *= 2

    fa = np.fft.fft(a, size)
    fb = np.fft.fft(b, size)
    coefficients = np.rint(np.fft.ifft(fa * fb).real).astype(np.int64)

    carry = 0
    digits = []
    for value in coefficients:
        total = int(value) + carry
        digits.append(total % 10)
        carry = total // 10

    while carry:
        digits.append(carry % 10)
        carry //= 10

    while len(digits) > 1 and digits[-1] == 0:
        digits.pop()

    return ''.join(map(str, digits[::-1]))

print(fft_multiply("123456789012345", "987654321098765"))

Bu uygulama öğreticidir; kayan nokta hataları nedeniyle gerçekten milyonlarca basamakta güvenilir olmayabilir. Pratik sistemler basamakları daha büyük bloklara ayırır veya modüler aritmetik kullanan Sayı Teorik Dönüşümü’nü (NTT) tercih eder. Birden fazla asal modülle yapılan sonuçlar Çin Kalan Teoremi aracılığıyla birleştirilebilir.

Sonuçta FFT yalnızca ses ve görüntü analizi yapan bir araç değildir. Büyük sayı çarpımını polinom çarpımına, polinom çarpımını konvolüsyona ve konvolüsyonu ucuz noktasal çarpımlara dönüştüren güçlü bir algoritmik köprüdür.

Klasik döngü yaklaşımı, önceki iki değeri saklayıp $F_2$’den $F_n$’e kadar ilerler. Bellek tüketimi $O(1)$ olsa da çalışma süresi $O(n)$ olur. Buradaki kritik gözlem, bir sonraki durumun mevcut durumun doğrusal dönüşümü olmasıdır.

Durumumuzu sütun vektörü olarak yazalım:

Buradaki dönüşüm matrisi $A$ olsun. Aynı dönüşümü tekrar tekrar uyguladığımızda matris kuvvetleri ortaya çıkar:

Yani artık hedefimiz diziyi adım adım yürütmek değil, $A^{n-1}$ matrisini hızlı hesaplamaktır.

Hızlı üs alma neden logaritmiktir?

Bir sayının kuvvetini hesaplarken kullanılan ikili üs alma tekniği matrislerde de geçerlidir. Üs çiftse

olur. Üs tekse bir adet $A$ dışarı alınır:

Her adımda üs yaklaşık yarıya indiği için yalnızca $\log_2 n$ tur gerekir. Matris boyutu Fibonacci için sabit, yani $2\times2$ olduğundan her çarpım sabit maliyetlidir.

Aşağıdaki C++ kodu sonucu bir modüler sayı altında hesaplar. Mod kullanmak önemlidir; çünkü Fibonacci sayıları son derece hızlı büyür ve standart tam sayı türlerine sığmaz.

#include <iostream>
using namespace std;

const long long MOD = 1'000'000'007;

struct Matrix {
    long long a[2][2]{};
};

Matrix multiply(const Matrix& x, const Matrix& y) {
    Matrix result;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            for (int k = 0; k < 2; ++k)
                result.a[i][j] =
                    (result.a[i][j] + x.a[i][k] * y.a[k][j]) % MOD;
    return result;
}

Matrix power(Matrix base, long long exponent) {
    Matrix result;
    result.a[0][0] = result.a[1][1] = 1; // Birim matris

    while (exponent > 0) {
        if (exponent & 1)
            result = multiply(result, base);
        base = multiply(base, base);
        exponent >>= 1;
    }
    return result;
}

long long fibonacci(long long n) {
    if (n == 0) return 0;
    Matrix transition{{{1, 1}, {1, 0}}};
    return power(transition, n - 1).a[0][0];
}

int main() {
    cout << fibonacci(1'000'000'000) << '\n';
}

multiply iki dönüşümü birleştirir; power ise üssün ikili gösterimini kullanır. Başlangıçta sonuç birim matristir, çünkü $A^0=I$ olmalıdır. Üssün ilgili biti bir olduğunda mevcut taban sonuca katılır.

Yalnızca Fibonacci değil

Bu yöntem, sabit katsayılı her doğrusal tekrarlamaya uygulanabilir. Örneğin

için dönüşüm matrisi

olur. Daha fazla geçmiş terime bağlı bağıntılarda matris boyutu büyür; mantık değişmez. Böylece matris, dizinin hafızasını taşıyan küçük bir zaman makinesine dönüşür: milyarlarca adımı tek tek yürümek yerine onları logaritmik sayıda sıçramayla geçer.

``

Möbius fonksiyonu nedir?

Möbius fonksiyonu $\mu(n)$, pozitif tam sayıları üç gruba ayırır:

Örneğin $\mu(6)=1$ olur; çünkü $6=2\cdot3$ ve iki farklı asal çarpanı vardır. Buna karşılık $12$, $2^2$ ile bölündüğü için $\mu(12)=0$ değerini alır.

Fonksiyonun sihirli özelliği şudur:

Bu eşitlik, istenmeyen ortak bölenleri artı ve eksi işaretlerle yok eden kapsama-dışlama ilkesinin aritmetik karşılığıdır.

Möbius inversiyon formülü

Bir $f$ fonksiyonunun bölenler üzerindeki toplamıyla $g$ fonksiyonu tanımlansın:

Möbius inversiyonu, toplamın içine saklanmış $f$ değerini geri çıkarır:

Bunun klasik örneği Euler’in totient fonksiyonudur. $n$ sayısının pozitif bölenlerinin totient değerleri toplamı $n$ eder:

İnversiyon uygulandığında doğrudan şu formül elde edilir:

Aralarında asal çiftleri saymak

$1\leq a,b\leq N$ koşulunu sağlayan ve $\gcd(a,b)=1$ olan sıralı çiftleri sayalım. Bir çiftin her iki elemanı da $d$ ile bölünüyorsa yaklaşık değil, tam olarak $\lfloor N/d\rfloor^2$ seçenek vardır. Möbius fonksiyonu ortak bölenleri kapsama-dışlama ile temizler:

Burada $\mu(d)=0$ olan kare çarpanlı değerler otomatik olarak elenir. Tek sayıda farklı asal içerenler çıkarılır, çift sayıda asal içerenler yeniden eklenir. Kısacası Möbius fonksiyonu, kapsama-dışlamanın muhasebecisidir; üstelik hesap makinesini hiç düşürmez!

Python ile doğrusal elek

Aşağıdaki kod, $1$ ile $N$ arasındaki Möbius değerlerini doğrusal zamanda üretir ve aralarında asal sıralı çiftlerin sayısını hesaplar:

def mobius_sieve(n):
    mu = [0] * (n + 1)
    mu[1] = 1
    primes, composite = [], [False] * (n + 1)

    for i in range(2, n + 1):
        if not composite[i]:
            primes.append(i)
            mu[i] = -1
        for p in primes:
            if i * p > n:
                break
            composite[i * p] = True
            if i % p == 0:
                mu[i * p] = 0
                break
            mu[i * p] = -mu[i]
    return mu


def coprime_pairs(n):
    mu = mobius_sieve(n)
    return sum(mu[d] * (n // d) ** 2 for d in range(1, n + 1))

print(coprime_pairs(10))  # 63

Elek her bileşik sayıyı kontrollü biçimde işler; böylece karmaşıklık $O(N)$, toplam hesabı da $O(N)$ olur. Büyük sınırlar için $\lfloor N/d\rfloor$ değerlerinin yalnızca yaklaşık $2\sqrt N$ farklı değer aldığından yararlanılarak gruplama yapılabilir.

Möbius inversiyonunu gördüğünüzde temel soruyu sorun: “Elimdeki fonksiyon, bölenler üzerinden birikmiş başka bir bilginin toplamı mı?” Yanıt evetse, tersine çevirme formülü büyük olasılıkla problemi birkaç satırlık temiz bir toplama indirecektir.

``

Centroid nedir?

Bir ağacın centroid’i, kaldırıldığında geriye kalan bağlı bileşenlerin hiçbirinin toplam düğüm sayısının yarısından büyük olmadığı düğümdür. $n$ düğümlü bir ağaçta centroid $c$ ise her bileşen için şu koşul geçerlidir:

Her ağacın en az bir, en fazla iki centroid’i vardır. Algoritmada bunlardan herhangi birini seçebiliriz. Centroid’i kaldırır, oluşan alt ağaçların her birine aynı işlemi özyineli uygularız. Her seviyede parça boyutu en az yarıya indiğinden decomposition yüksekliği $O(\log n)$ olur.

LCA iki belirli düğümün mesafesinde harikadır. Centroid Decomposition ise “işaretli en yakın düğüm”, “$k$ mesafedeki düğüm sayısı” veya dinamik renk güncellemeleri gibi toplu problemlerde parlar.

Centroid nasıl bulunur?

Önce alt ağaç boyutlarını hesaplarız. Ardından boyutu toplamın yarısından büyük olan bir çocuk varsa o yöne ilerleriz. Böyle bir çocuk kalmadığında centroid’i bulmuş oluruz.

int calcSize(int u, int p) {
    sub[u] = 1;
    for (int v : graph[u])
        if (v != p && !removed[v])
            sub[u] += calcSize(v, u);
    return sub[u];
}

int findCentroid(int u, int p, int total) {
    for (int v : graph[u])
        if (v != p && !removed[v] && sub[v] > total / 2)
            return findCentroid(v, u, total);
    return u;
}

void decompose(int entry, int parent) {
    int total = calcSize(entry, -1);
    int c = findCentroid(entry, -1, total);
    centroidParent[c] = parent;
    removed[c] = true;

    for (int v : graph[c])
        if (!removed[v]) decompose(v, c);
}

removed dizisi centroid olarak ayrılmış düğümlerin sonraki hesaplamalara katılmasını engeller. centroidParent ise yeni centroid ağacındaki ebeveyn ilişkisini saklar.

En yakın işaretli düğüm uygulaması

Başlangıçta bazı düğümlerin kırmızı olduğunu düşünelim. Bir düğümü kırmızıya boyamak ve verilen $u$ düğümüne en yakın kırmızının mesafesini bulmak istiyoruz. Her centroid için kendisine en yakın kırmızı düğümün mesafesini best dizisinde tutarız.

void paint(int u) {
    int x = u;
    while (x != -1) {
        best[x] = min(best[x], distance(u, x));
        x = centroidParent[x];
    }
}

int query(int u) {
    int answer = INF;
    int x = u;
    while (x != -1) {
        answer = min(answer, best[x] + distance(u, x));
        x = centroidParent[x];
    }
    return answer;
}

Buradaki distance(a, b) değeri LCA ile $O(\log n)$ sürede veya centroid atalarına ait önceden saklanmış mesafelerle $O(1)$ sürede alınabilir. İkinci seçenek kullanıldığında güncelleme ve sorgu doğrudan $O(\log n)$ olur.

Temel fikir şudur: Her düğüm yalnızca $O(\log n)$ centroid atasına sahiptir. Olası cevapları bu dengeli ata zinciri üzerinden birleştiririz. Böylece kocaman ağacı her sorguda dolaşmak yerine birkaç stratejik ağırlık merkezine uğrarız; algoritmik anlamda tam bir “merkeze çekilme” hareketi!

Bir şirket hiyerarşisindeki yöneticileri, dosya sistemindeki klasörleri veya bir oyundaki yetenek ağacını düşünün. Bu yapılarda “X düğümünün altındaki bütün değerlerin toplamı nedir?” gibi sorgular sıkça karşımıza çıkar. Ağacı her sorguda yeniden dolaşmak pahalıdır; Euler Turu Tekniği (ETT), alt ağaçları tek boyutlu ve kesintisiz dizi aralıklarına dönüştürerek segment ağacının süper güçlerinden yararlanmamızı sağlar.

``

Temel fikir: Ağacı ütülemek

Köklü bir ağaçta DFS dolaşması yaparken her düğüme giriş zamanını tin[v] olarak kaydedelim. Düğümün bütün çocuklarını ziyaret ettikten sonra da alt ağacının bittiği konumu tout[v] ile işaretleyelim.

DFS, bir düğüme girdikten sonra başka bir dala geçmeden önce o düğümün tüm torunlarını ziyaret eder. Dolayısıyla v düğümünün alt ağacındaki düğümler, oluşturduğumuz dizide şu kesintisiz aralığa yerleşir:

Düğüm değerlerini giriş sırasına göre flat dizisine yazarsak alt ağaç toplamı artık ağaç üzerinde değil, sıradan bir aralık üzerinde hesaplanır:

Örneğin DFS sırası A, B, D, E, C, F olsun. B düğümünün altında B, D, E bulunuyorsa bunlar dizide yan yana durur. Ağaç karmaşık görünse bile sorgu yalnızca [1, 3] aralığıdır. Kısacası ağaç ütülenmiş, kırışıklıklar kaybolmuştur!

Buradaki $k$, sorgulanan alt ağaçtaki düğüm sayısıdır. Ağaç zincir şeklindeyse $k$, $n$ kadar büyüyebilir.

Euler dizisini oluşturmak

Aşağıdaki Python kodu, her düğümü yalnızca giriş anında diziye ekleyen yaygın ETT çeşidini uygular:

def build_euler(graph, values, root=0):
    n = len(graph)
    tin = [0] * n
    tout = [0] * n
    flat = []

    def dfs(node, parent):
        tin[node] = len(flat)
        flat.append(values[node])

        for child in graph[node]:
            if child != parent:
                dfs(child, node)

        tout[node] = len(flat) - 1

    dfs(root, -1)
    return tin, tout, flat

tin[node], düğümün değerinin flat içindeki konumudur. tout[node] ise son torunun konumunu gösterir. Böylece alt ağaç aralığı iki indeksle temsil edilir.

Segment ağacıyla sorgulamak

Aşağıdaki sınıf noktasal güncelleme ve aralık toplamı işlemlerini $O(\log n)$ zamanda gerçekleştirir:

class SegmentTree:
    def __init__(self, data):
        size = 1
        while size < len(data):
            size *= 2
        self.size = size
        self.tree = [0] * (2 * size)

        for i, value in enumerate(data):
            self.tree[size + i] = value
        for i in range(size - 1, 0, -1):
            self.tree[i] = self.tree[2 * i] + self.tree[2 * i + 1]

    def update(self, index, value):
        i = self.size + index
        self.tree[i] = value
        while i > 1:
            i //= 2
            self.tree[i] = self.tree[2 * i] + self.tree[2 * i + 1]

    def query(self, left, right):
        left += self.size
        right += self.size
        total = 0
        while left <= right:
            if left % 2 == 1:
                total += self.tree[left]
                left += 1
            if right % 2 == 0:
                total += self.tree[right]
                right -= 1
            left //= 2
            right //= 2
        return total

Kullanımı oldukça nettir:

tin, tout, flat = build_euler(graph, values)
segment = SegmentTree(flat)

subtree_sum = segment.query(tin[v], tout[v])
segment.update(tin[v], new_value)

İnce noktalar

ETT’nin farklı tanımları vardır. Bazı sürümlerde düğüm hem girişte hem çıkışta kaydedilir. Alt ağaç sorgularında genellikle her düğümü bir kez yazan sürüm daha pratiktir. Aralıkların kapalı mı [l, r], yoksa yarı açık mı [l, r) olduğunu da baştan belirlemek önemlidir; indeks hatalarının doğal yaşam alanı tam olarak burasıdır.

Ağaç değişmiyor fakat değerler güncelleniyorsa ETT mükemmel bir seçimdir. Yalnızca toplam gerekiyorsa Fenwick ağacı da kullanılabilir. Minimum, maksimum veya daha gelişmiş birleştirme işlemlerinde ise segment ağacı daha esnektir. Sonuç olarak ETT tek başına sorguları cevaplamaz; ağacın geometrisini, güçlü dizi veri yapılarına uygun bir forma dönüştüren zekice bir köprüdür.

Bir alfabenin karakterlerini kullanarak belirli uzunlukta metinler üretmek kolaydır: alfabe boyutu $K$, metin uzunluğu $N$ ise toplam $K^N$ seçenek vardır. Ancak metnin içinde “abc”, “kedi” veya “virus” gibi yasaklı kelimelerin hiç geçmemesini istediğimizde işler karışır. Her dizgiyi tek tek üretip kontrol etmek astronomik derecede pahalıdır. Neyse ki Aho-Corasick otomatı ile dinamik programlamayı birleştirerek tüm geçerli dizgileri üretmeden sayabiliriz.

``

Problemi neden bir otomat olarak düşünmeliyiz?

Yasaklı kelimeleri kontrol ederken geçmişin tamamını hatırlamamız gerekmez. Yalnızca şimdiye kadar yazdığımız metnin, yasaklı kelimelerden birinin öneki olabilecek en uzun son ekini bilmek yeterlidir.

Örneğin yasaklı kelimeler aba ve bab olsun. Üretilen metin ...ab ile bitiyorsa yeni karakter önemlidir: a eklenirse aba tamamlanır ve durum geçersiz olur. Aho-Corasick, bu tür bilgileri trie düğümleri ve failure bağlantılarıyla temsil eder.

Bir düğüm terminalse veya failure zincirinde terminal bir düğüme ulaşıyorsa o durum “tehlikeli” kabul edilmelidir. Çünkü yasaklı kelime metnin sonunda zaten görülmüştür.

Dinamik programlama modeli

$dp[i][s]$, uzunluğu $i$ olan ve Aho-Corasick otomatının $s$ durumunda biten geçerli dizgilerin sayısı olsun. Başlangıçta boş dizgi kök durumundadır:

Her durumdan alfabedeki tüm karakterleri deneriz. Otomatın geçiş fonksiyonu $go(s,c)$ ile gösterilirse, hedef durum tehlikeli olmadığı sürece geçiş şöyledir:

Sonuç, $N$ karakter işlendiğinde güvenli durumların toplamıdır:

Bu yaklaşımın zaman karmaşıklığı $O(N \cdot S \cdot K)$ olur. Burada $S$ otomat durumlarının, $K$ ise alfabenin büyüklüğüdür. Kaba kuvvetin $O(K^N)$ maliyetiyle karşılaştırıldığında fark oldukça dramatiktir.

C++ ile örnek DP

Aşağıdaki bölüm, otomatın daha önce oluşturulduğunu varsayar. nextState[s][c] geçişleri, bad[s] ise yasaklı bir eşleşmeye ulaşan durumları tutar:

const long long MOD = 1'000'000'007;

long long countValid(int n, int stateCount, int alphabetSize,
                     const vector<vector<int>>& nextState,
                     const vector<bool>& bad) {
    vector<long long> current(stateCount, 0), next(stateCount, 0);
    current[0] = 1; // Boş metin kök durumunda başlar.

    for (int length = 0; length < n; ++length) {
        fill(next.begin(), next.end(), 0);

        for (int state = 0; state < stateCount; ++state) {
            if (bad[state] || current[state] == 0) continue;

            for (int ch = 0; ch < alphabetSize; ++ch) {
                int target = nextState[state][ch];
                if (bad[target]) continue;

                next[target] = (next[target] + current[state]) % MOD;
            }
        }
        current.swap(next);
    }

    long long answer = 0;
    for (int state = 0; state < stateCount; ++state)
        if (!bad[state]) answer = (answer + current[state]) % MOD;

    return answer;
}

Kodda yalnızca önceki uzunluğun değerleri gerektiği için iki DP satırı kullanılır. Böylece bellek karmaşıklığı $O(N \cdot S)$ yerine $O(S)$ seviyesine iner.

Dikkat edilmesi gereken ayrıntılar

Failure bağlantısından terminal bilgisini miras almak kritik önemdedir. Aksi hâlde otomat, daha uzun bir durumun son eki olarak tamamlanan yasaklı kelimeleri kaçırabilir. Ayrıca sonuçlar hızla büyüdüğünden çoğu yarışma probleminde modüler aritmetik kullanılır.

Çok büyük $N$ değerlerinde aynı model bir geçiş matrisi hâline getirilebilir ve matris hızlı üs alma ile yaklaşık $O(S^3 \log N)$ sürede çözülebilir. Böylece Aho-Corasick yalnızca kelime arayan bir algoritma olmaktan çıkar; güvenli metinlerin evrenini sayan güçlü bir kombinatorik makineye dönüşür.

Önce problemi ikili düşünelim

Bir bitin değeri 1 ise o bit set edilmiş, 0 ise temizlenmiş kabul edilir. Örneğin $n=52$ sayısının ikili gösterimi şöyledir:

Bu gösterimde üç tane 1 bulunduğundan sonuç 3’tür. Klasik yaklaşım, sayının en sağındaki biti n & 1 ile kontrol eder ve ardından sayıyı sağa kaydırır. Sayı $b$ bit uzunluğundaysa bu yöntem yaklaşık $b$ tur çalışır.

Burada $k$, sayının içindeki 1 bitlerinin sayısıdır. Seyrek bitli sayılarda $k \ll b$ olduğundan fark oldukça belirgin olabilir.

Hilenin kalbi: n & (n - 1)

Algoritmanın temel ifadesi şudur:

n = n & (n - 1)

Bir sayıdan 1 çıkarıldığında, en sağdaki set bit 0 olur; onun sağındaki bütün 0 bitleri ise 1 olur. Ardından eski sayı ile yeni sayı arasında AND işlemi yapıldığında bu değişen alt bitler temizlenir. Sonuç olarak sayının en sağındaki tek bir 1 yok edilir.

Örneğin $52$ üzerinden ilerleyelim:

Sayı sıfıra üç turda ulaştığı için set bit sayısı da 3’tür. Algoritma, aradaki sıfırlarla hiç vakit kaybetmez.

C ile uygulama

Aşağıdaki fonksiyon, işaretsiz bir tam sayıdaki set bitlerini sayar:

unsigned int count_set_bits(unsigned int n) {
    unsigned int count = 0;

    while (n != 0) {
        n &= (n - 1);  // En sağdaki set bitini temizler.
        count++;
    }

    return count;
}

unsigned int kullanılması önemlidir. İşaretli negatif sayıların gösterimi ve taşma davranışları dile göre kafa karıştırabilir. İşaretsiz tür, işlemin sabit genişlikte bir bit deseni üzerinde gerçekleştiğini daha açık biçimde ifade eder.

Python’da aynı fikir neredeyse birebir yazılabilir:

def count_set_bits(n: int) -> int:
    if n < 0:
        raise ValueError("n negatif olmamalıdır")

    count = 0
    while n:
        n &= n - 1
        count += 1
    return count

Ne zaman tercih edilmeli?

Bu yöntem; bit bayraklarını analiz ederken, izin sistemlerinde etkin seçenekleri sayarken, grafik algoritmalarındaki bit kümelerinde ve gömülü sistemlerde oldukça kullanışlıdır. Yine de modern dillerin bit_count, popcount veya benzeri yerleşik fonksiyonları işlemcinin özel komutlarından yararlanabilir. Python’da örneğin n.bit_count() çoğunlukla elle yazılan döngüden daha hızlıdır.

Brian Kernighan yaklaşımının asıl değeri yalnızca performans değildir. n & (n - 1) ifadesi, bitlerin matematiksel yapısını kullanarak problemi dönüştürür: bütün bitleri aramak yerine bulunan her 1 doğrudan silinir. Kısacası algoritma samanlıkta iğne aramaz; iğneleri sırayla ortadan kaldırır.

Circuit Breaker neyi çözer?

Bir sipariş servisinin ödeme servisini çağırdığını düşünelim. Ödeme servisi yanıt veremiyorsa her isteği tekrar tekrar ona göndermek problemi çözmez; aksine ağ trafiğini ve kaynak tüketimini artırır. Circuit Breaker, belirli sayıdaki başarısızlıktan sonra çağrıları geçici olarak engeller ve hızlı hata döndürür.

Bir çağrının ortalama bekleme süresi $T$, eş zamanlı istek sayısı $N$ ise bloke edilen toplam kaynak baskısını kabaca şöyle düşünebiliriz:

Örneğin 500 istek 10 saniye boyunca beklerse sistemde $5000$ istek-saniyelik baskı oluşur. Devre açıkken çağrının 10 milisaniyede reddedilmesi bu maliyeti dramatik biçimde azaltır.

Üç temel durum

Circuit Breaker küçük bir durum makinesi olarak çalışır:

İsimler ilk bakışta ters gelebilir. Elektrik devresinde closed, akımın geçtiği; open ise akımın kesildiği durumdur. Burada “akım”, servis çağrılarıdır.

Hata oranı $E$, başarısız çağrı sayısı $F$ ve toplam çağrı sayısı $R$ ile hesaplanabilir:

Son 20 çağrının 12’si başarısızsa hata oranı yüzde 60’tır. Eşik yüzde 50 olarak ayarlanmışsa devre açılabilir. Ancak yalnızca oran kullanmak risklidir: İki çağrıdan birinin başarısız olması da yüzde 50 eder. Bu nedenle minimum örnek sayısı belirlemek önemlidir.

JavaScript ile sade bir uygulama

Aşağıdaki sınıf, art arda gelen hataları sayar; eşik aşılınca çağrıları durdurur ve belirlenen sürenin ardından kontrollü bir denemeye izin verir:

class CircuitBreaker {
  constructor(action, threshold = 3, resetTime = 5000) {
    this.action = action;
    this.threshold = threshold;
    this.resetTime = resetTime;
    this.failures = 0;
    this.state = "CLOSED";
    this.openedAt = null;
  }

  async execute(...args) {
    if (this.state === "OPEN") {
      const elapsed = Date.now() - this.openedAt;
      if (elapsed < this.resetTime) {
        throw new Error("Devre açık: çağrı engellendi");
      }
      this.state = "HALF_OPEN";
    }

    try {
      const result = await this.action(...args);
      this.failures = 0;
      this.state = "CLOSED";
      return result;
    } catch (error) {
      this.failures++;
      if (this.state === "HALF_OPEN" || this.failures >= this.threshold) {
        this.state = "OPEN";
        this.openedAt = Date.now();
      }
      throw error;
    }
  }
}

Sınıf gerçek projelerde zaman aşımı, kayan pencere, eş zamanlı Half-Open denemelerini sınırlama ve metrik toplama gibi özelliklerle genişletilmelidir. Hazır çözümler için Java ekosisteminde Resilience4j, .NET tarafında Polly kullanılabilir.

Retry ile aynı şey mi?

Bu desenler rakip değil, ekip arkadaşıdır. İyi bir akışta önce timeout uygulanır, yalnızca geçici hatalar dikkatli biçimde retry edilir, hata yoğunluğu artarsa devre açılır ve mümkünse önbellekten fallback yanıtı sunulur.

Sonuç

Circuit Breaker bozuk servisi tamir etmez; sistemin geri kalanına nefes alacak alan kazandırır. Başarı için eşikleri trafik karakterine göre ayarlamak, devre durumlarını izlemek ve alarm üretmek gerekir. Çünkü dağıtık sistemlerde soru “Bir servis çöker mi?” değil, “Çöktüğünde sistem ne kadar zarif davranır?” olmalıdır.