``

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.

``

Minimum ortalama döngü nedir?

Yönlü ve ağırlıklı bir grafı $G=(V,E)$ olarak tanımlayalım. Bir $C$ döngüsünün ortalama ağırlığı, döngüdeki toplam maliyetin kenar sayısına bölünmesidir:

Amaç, bütün yönlü döngüler arasında $μ(C)$ değerini en aza indirmektir. Burada aranan şey toplam ağırlığı en düşük döngü değildir. Örneğin iki kenarlı ve toplam ağırlığı 8 olan bir döngünün ortalaması 4; beş kenarlı ve toplam ağırlığı 10 olan başka bir döngünün ortalaması 2’dir. Toplam maliyeti daha yüksek olan ikinci döngü, uzun vadede daha avantajlıdır.

Karp’ın dinamik programlama fikri

Grafın $n=\vert V\vert $ düğümü olduğunu varsayalım. Bir başlangıç düğümü $s$ seçilir ve $d_k(v)$, tam olarak $k$ kenar kullanarak $s$ düğümünden $v$ düğümüne ulaşmanın minimum maliyeti olarak tanımlanır:

Başlangıçta $d_0(s)=0$, diğer değerler sonsuzdur. Karp’ın önemli sonucu, güçlü bağlı bir graf için minimum döngü ortalamasını şu formülle verir:

Neden $n$ adım? Çünkü $n$ düğümlü bir graf üzerinde $n$ kenarlık bir yürüyüş mutlaka en az bir düğümü tekrar ziyaret eder; yani içinde bir döngü bulunur. Farklı $k$ noktalarından kalan parçaların ortalamaları karşılaştırıldığında, tekrarın sürdürülebilir en düşük maliyeti görünür hâle gelir.

Python ile uygulama

Aşağıdaki kod, düğümleri 0 ile n-1 arasında numaralanmış bir graf için minimum ortalama değeri hesaplar:

def karp_minimum_cycle_mean(n, edges, source=0):
    inf = float("inf")
    dp = [[inf] * n for _ in range(n + 1)]
    dp[0][source] = 0

    # Tam olarak k kenarlı en ucuz yürüyüşleri hesapla.
    for k in range(1, n + 1):
        for u, v, weight in edges:
            if dp[k - 1][u] != inf:
                candidate = dp[k - 1][u] + weight
                dp[k][v] = min(dp[k][v], candidate)

    answer = inf
    for v in range(n):
        if dp[n][v] == inf:
            continue

        worst_ratio = -inf
        for k in range(n):
            if dp[k][v] != inf:
                ratio = (dp[n][v] - dp[k][v]) / (n - k)
                worst_ratio = max(worst_ratio, ratio)

        answer = min(answer, worst_ratio)

    return answer

Dinamik programlama tablosu $n+1$ satır ve $n$ sütun içerir. Her satırda bütün kenarlar gevşetildiği için zaman karmaşıklığı $O(nm)$, bellek karmaşıklığı ise $O(n^2)$ olur. Burada $m=\vert E\vert $ değeridir.

Darboğaz analizindeki anlamı

Ağırlıklar gecikmeyi temsil ediyorsa minimum ortalama döngü, sistemde tekrar başına erişilebilecek en düşük maliyeti gösterir. Ağırlıklar kazanç veya kapasite olarak yorumlanıyorsa işaretleri değiştirerek maksimum ortalama döngü de bulunabilir. Böylece zamanlanmış devrelerde çevrim süresi, üretim ağlarında tekrar maliyeti ve olay sistemlerinde uzun dönem verimi analiz edilebilir.

Algoritmanın verdiği temel sonuç sayısal ortalamadır; döngünün kenarlarını doğrudan döndürmez. Gerçek döngüyü çıkarmak için öncül düğümler saklanmalı ve tekrar eden düğümler geriye doğru izlenmelidir. Ayrıca graf güçlü bağlı değilse her güçlü bağlı bileşeni ayrı incelemek, ulaşılamayan bölgelerin sonucu bozmasını engeller. Kısacası Karp’ın yaklaşımı, “Sistem sonsuza dek çalışırsa hangi tekrar performansı belirler?” sorusuna matematiksel ve uygulanabilir bir cevap verir.

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.

``

Problemin matematiksel modeli

Yönlü bir ağdaki her $(u,v)$ kenarı iki değere sahiptir: kapasite $c(u,v)$ ve birim akış maliyeti $w(u,v)$. Kenardan geçirilen akış $f(u,v)$ ise şu koşulu sağlamalıdır:

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

Önce toplam akış miktarı $F$ maksimize edilir, ardından bu akışın maliyeti minimize edilir:

Bu öncelik önemlidir. Sadece en ucuz yolu seçmek maksimum akışa ulaşmayı engelleyebilir; sadece maksimum akış bulmak ise gereksiz derecede pahalı bir sonuç üretebilir.

Artık ağ neden gereklidir?

Algoritma her seçimden sonra bir artık ağ (residual graph) tutar. Kapasitesi kullanılan ileri kenarın artık kapasitesi azalır; ters yönde ise maliyeti $-w(u,v)$ olan bir kenar oluşur. Bu ters kenar, algoritmanın önceki kararından vazgeçebilmesini sağlar. Yani sistem yalnızca ilerlemez; gerektiğinde “Bu rota pek iyi olmadı” diyerek akışı geri alıp daha ucuz biçimde düzenler.

Yaygın yaklaşım, artık ağda maliyeti en düşük artırma yolunu bulup mümkün olan akışı bu yoldan göndermektir. Negatif kenarlar nedeniyle Bellman-Ford kullanılabilir. Daha hızlı uygulamalarda ise düğüm potansiyelleriyle maliyetler yeniden ağırlıklandırılır ve Dijkstra çalıştırılır.

İndirgenmiş maliyet şu şekilde hesaplanır:

Doğru potansiyeller altında $w’(u,v)\geq 0$ olur; böylece Dijkstra güvenle kullanılabilir.

Python ile temel uygulama

Aşağıdaki sürüm, anlaşılır olması için SPFA ile en ucuz artırma yolunu bulur:

from collections import deque

class Edge:
    def __init__(self, to, rev, cap, cost):
        self.to, self.rev = to, rev
        self.cap, self.cost = cap, cost

def add_edge(g, u, v, cap, cost):
    g[u].append(Edge(v, len(g[v]), cap, cost))
    g[v].append(Edge(u, len(g[u]) - 1, 0, -cost))

def min_cost_max_flow(g, source, target):
    n = len(g)
    flow = cost = 0

    while True:
        dist = [float('inf')] * n
        parent = [None] * n
        in_queue = [False] * n
        dist[source] = 0
        q = deque([source])

        while q:
            u = q.popleft()
            in_queue[u] = False
            for i, e in enumerate(g[u]):
                if e.cap > 0 and dist[e.to] > dist[u] + e.cost:
                    dist[e.to] = dist[u] + e.cost
                    parent[e.to] = (u, i)
                    if not in_queue[e.to]:
                        q.append(e.to)
                        in_queue[e.to] = True

        if parent[target] is None:
            break

        pushed = float('inf')
        v = target
        while v != source:
            u, i = parent[v]
            pushed = min(pushed, g[u][i].cap)
            v = u

        v = target
        while v != source:
            u, i = parent[v]
            e = g[u][i]
            e.cap -= pushed
            g[v][e.rev].cap += pushed
            cost += pushed * e.cost
            v = u

        flow += pushed

    return flow, cost

add_edge, ileri kenarla birlikte ters kenarı da oluşturur. Ana döngü en ucuz yolu bulur, yol üzerindeki darboğaz kapasiteyi hesaplar ve artık ağı günceller. Sonuç (maksimum_akış, minimum_maliyet) biçimindedir.

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

SPFA tabanlı yaklaşım pratikte kullanışlı olsa da en kötü durumda yavaşlayabilir. Bellman-Ford ile yaklaşık $O(FVE)$, potansiyel ve Dijkstra ile $O(FE\log V)$ davranışı beklenir; burada $F$ artırma sayısıyla ilişkilidir.

MCMF; kargo dağıtımı, çalışan-görev eşleştirmesi, üretim planlama, ağ paketlerinin yönlendirilmesi ve kaynak tahsisi gibi alanlarda kullanılır. Özetle soru “Ne kadar taşıyabilirim?” ile bitmiyor, “Bunu en akıllıca kaça taşırım?” diye devam ediyorsa sahne Min-Cost Max-Flow’undur.

``

Önce klasik Mo mantığı

Elimizde $Q$ adet $[L,R]$ sorgusu bulunan, uzunluğu $N$ olan bir dizi düşünelim. Her sorguyu bağımsız çözmek pahalıdır. Mo algoritması sorguları önce $L$ değerinin ait olduğu bloğa, ardından $R$ değerine göre sıralar. Blok boyutu genellikle $B \approx \sqrt{N}$ seçilir.

İki işaretçiyle güncel aralığı koruruz. Yeni sorguya geçerken elemanları yalnızca ekler veya çıkarırız. Ekleme ve çıkarma $O(1)$ ise yaklaşık karmaşıklık şöyledir:

Ağacı diziye çevirmek

Ağaçta iki düğüm arasındaki yol doğrudan tek bir dizi aralığı değildir. Çözüm, DFS sırasında oluşturulan Euler turudur. Her düğümü ağaca girerken ve düğümden çıkarken kaydederiz. Böylece $N$ düğümlü ağaç için $2N$ uzunluğunda bir dizi oluşur.

Bir düğümün Euler aralığında kaç kez göründüğüne dikkat ederiz:

• Bir kez görünüyorsa etkin kümededir.
• İki kez görünüyorsa iki ziyaret birbirini götürür.
• Hiç görünmüyorsa sorgunun yolunda değildir.

Bu nedenle işaretçi bir Euler konumuna geldiğinde düğümü doğrudan eklemek yerine durumunu toggle, yani aç/kapat yaparız. Bu yaklaşım biraz ışık anahtarına benzer: aynı düğmeye ikinci kez basınca oda eski hâline döner.

vector<int> euler, color, freq;
vector<bool> active;
int distinctColors = 0;

void toggle(int position) {
    int node = euler[position];
    int c = color[node];

    if (active[node]) {
        if (--freq[c] == 0) distinctColors--;
    } else {
        if (freq[c]++ == 0) distinctColors++;
    }
    active[node] = !active[node];
}

Burada freq[c], etkin düğümler arasında c renginin kaç defa bulunduğunu tutar. distinctColors ise güncel yol üzerindeki farklı renk sayısıdır. Renk değerleri büyükse önce koordinat sıkıştırma uygulanmalıdır.

LCA neden gerekiyor?

$u$ ve $v$ düğümleri için önce giriş zamanlarına göre sıralama yapılır. Eğer $u$, $v$ düğümünün atasıysa yol uygun bir Euler aralığıyla temsil edilir. Değilse aralık, yolun büyük bölümünü kapsar fakat $LCA(u,v)$ düğümünü dışarıda bırakır.

Bu durumda sorgu cevaplanmadan hemen önce LCA geçici olarak etkinleştirilir, sonuç kaydedilir ve ardından tekrar kapatılır. İkili kaldırma kullanıldığında LCA hesabı $O(\log N)$ sürede yapılabilir.

Sorguları sıralamak

Her yol sorgusu, hesaplanan sol ve sağ Euler sınırlarıyla saklanır. Sonra klasik blok karşılaştırması uygulanır:

sort(queries.begin(), queries.end(), [&](const Query& a, const Query& b) {
    int blockA = a.left / blockSize;
    int blockB = b.left / blockSize;
    if (blockA != blockB) return blockA < blockB;

    // Zikzak sıralama sağ işaretçinin hareketini azaltır.
    if (blockA & 1) return a.right > b.right;
    return a.right < b.right;
});

Ağaç üzerinde Mo algoritması çevrimdışıdır; cevap vermeden önce bütün sorguları bilmek gerekir. Buna karşılık güncelleme bulunmayan, çok sayıda yol sorgusu içeren problemlerde oldukça güçlüdür. Özet tarif şudur: ağacı Euler turuyla düzleştir, sorguları bloklara ayır, düğümleri toggle et ve LCA’nın eksik kaldığı köşeleri dikkatle tamamla. Gerisi, iki işaretçinin ormanda düzenli bir yürüyüşünden ibarettir.

``

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.

Kalıcılık fikri nedir?

Persistent, yani kalıcı, bir veri yapısında önceki sürümler değişmeden erişilebilir kalır. Dizinin başlangıç durumuna versiyon 0, ilk güncellemeden sonraki durumuna versiyon 1 diyebiliriz. Her versiyonun Segment Tree kökünü ayrı bir dizide saklamak yeterlidir.

Bir Segment Tree güncellemesinde kökten yaprağa yalnızca tek yol değişir. Dizinin boyutu $n$ ise bu yolun uzunluğu $O(\log n)$ olur. Dolayısıyla yeni sürüm için tüm $O(n)$ düğümleri kopyalamak yerine yaklaşık $O(\log n)$ yeni düğüm oluştururuz. Değişmeyen alt ağaçlar eski ve yeni sürümler tarafından ortak kullanılır.

$u$ güncelleme sonrasında toplam bellek maliyeti yaklaşık olarak:

Bu tekniğe path copying, yani yol kopyalama adı verilir.

Düğümler nasıl paylaşılır?

Her düğüm; tuttuğu toplamı, sol çocuk indeksini ve sağ çocuk indeksini saklar. Güncelleme başladığında eski düğüm kopyalanır. Değişiklik hangi taraftaysa yalnızca o çocuk yeniden oluşturulur; diğer çocuğun indeksi eski sürümden alınır. Böylece iki farklı zaman çizgisi aynı değişmemiş dalları paylaşabilir.

Aşağıdaki C++ örneği, noktasal değer atama ve geçmiş bir sürümde aralık toplamı sorgulama işlemlerini gerçekleştirir:

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

struct Node {
    long long sum;
    int left, right;
};

vector<Node> tree;
vector<int> roots;

int build(const vector<int>& a, int l, int r) {
    int node = tree.size();
    tree.push_back({0, -1, -1});

    if (l == r) {
        tree[node].sum = a[l];
        return node;
    }

    int mid = (l + r) / 2;
    tree[node].left = build(a, l, mid);
    tree[node].right = build(a, mid + 1, r);
    tree[node].sum = tree[tree[node].left].sum
                   + tree[tree[node].right].sum;
    return node;
}

int update(int old, int l, int r, int pos, int value) {
    int node = tree.size();
    tree.push_back(tree[old]); // Eski düğümün kopyası

    if (l == r) {
        tree[node].sum = value;
        return node;
    }

    int mid = (l + r) / 2;
    if (pos <= mid)
        tree[node].left = update(tree[old].left, l, mid, pos, value);
    else
        tree[node].right = update(tree[old].right, mid + 1, r, pos, value);

    tree[node].sum = tree[tree[node].left].sum
                   + tree[tree[node].right].sum;
    return node;
}

long long query(int node, int l, int r, int ql, int qr) {
    if (qr < l || r < ql) return 0;
    if (ql <= l && r <= qr) return tree[node].sum;

    int mid = (l + r) / 2;
    return query(tree[node].left, l, mid, ql, qr)
         + query(tree[node].right, mid + 1, r, ql, qr);
}

İlk kök roots.push_back(build(a, 0, n - 1)) ile kaydedilir. Yeni bir sürüm oluşturmak için roots.push_back(update(roots.back(), 0, n - 1, konum, deger)) çağrılır. Örneğin üçüncü sürümde [2, 6] toplamı query(roots[3], 0, n - 1, 2, 6) ile bulunur.

Nerelerde kullanılır?

Persistent Segment Tree; geçmiş durum sorgularında, geri alma sistemlerinde, çevrim dışı sorgularda ve bir aralıktaki $k$’ıncı küçük elemanı bulma problemlerinde oldukça etkilidir. Git’in commit geçmişini düşünmek iyi bir benzetmedir: Her sürüm tamamen bağımsız görünür, fakat değişmeyen içerik yeniden kullanılabilir.

En önemli ayrıntı, eski düğümleri asla değiştirmemektir. Yanlışlıkla eski bir çocuk üzerinde güncelleme yapmak bütün zaman çizgisini bozabilir. Doğru uygulandığında ise geçmiş, silinen bir kayıt değil; yalnızca doğru kökü seçerek ziyaret edebileceğiniz başka bir versiyondur.

``

Temel fikir

Kenarları eksenlere paralel bir dikdörtgeni $(x_1,y_1,x_2,y_2)$ ile gösterelim. Dikey tarama çizgisi yalnızca bir dikdörtgenin sol veya sağ kenarına ulaştığında aktif dikdörtgen kümesi değişir. Bu nedenle her dikdörtgenden iki olay üretiriz:

• $x_1$ konumunda dikdörtgenin $[y_1,y_2)$ aralığını ekle.
• $x_2$ konumunda aynı aralığı kaldır.

Ardışık olay koordinatları $x_i$ ve $x_{i+1}$ arasında aktif küme sabittir. Bu şeritte en az iki kez kaplanan toplam dikey uzunluk $L_i$ ise alana katkı

olur. Sonuç, bütün şeritlerin toplamıdır:

Böylece alan hesabı, aktif $y$ aralıklarında en az iki kat örtülen uzunluğu bulma problemine indirgenir.

Orta ölçekli bir Python çözümü

Aşağıdaki uygulama, her $x$ şeridinde aktif aralıkların uç noktalarını tarar. En az iki aralığın örttüğü dikey uzunluğu hesapladığı için üç veya daha fazla dikdörtgenin ortak bölgesi yalnızca bir kez alana eklenir.

def overlap_y_length(intervals):
    """En az iki aktif aralık tarafından kaplanan y uzunluğunu döndürür."""
    points = []
    for y1, y2 in intervals:
        points.append((y1, 1))
        points.append((y2, -1))

    points.sort()
    covered = 0
    count = 0
    previous_y = None

    for y, delta in points:
        if previous_y is not None and count >= 2:
            covered += y - previous_y
        count += delta
        previous_y = y

    return covered


def rectangle_overlap_area(rectangles):
    """En az iki dikdörtgenin kapladığı birleşik kesişim alanını bulur."""
    events = []
    for rect_id, (x1, y1, x2, y2) in enumerate(rectangles):
        events.append((x1, 1, rect_id, y1, y2))   # ekle
        events.append((x2, -1, rect_id, y1, y2))  # kaldır

    events.sort()
    active = {}
    area = 0
    previous_x = events[0][0] if events else 0
    index = 0

    while index < len(events):
        x = events[index][0]
        width = x - previous_x
        area += width * overlap_y_length(active.values())

        # Aynı x koordinatındaki olayları birlikte uygula.
        while index < len(events) and events[index][0] == x:
            _, event_type, rect_id, y1, y2 = events[index]
            if event_type == 1:
                active[rect_id] = (y1, y2)
            else:
                active.pop(rect_id)
            index += 1

        previous_x = x

    return area

rectangles = [(0, 0, 4, 3), (2, 1, 6, 5), (3, 2, 5, 4)]
print(rectangle_overlap_area(rectangles))

Karmaşıklık ve geliştirme

Her şeritte aktif aralıklar yeniden sıralandığından bu öğretici sürümün en kötü durum maliyeti yaklaşık $O(n^2\log n)$ olabilir. Büyük veri kümelerinde $y$ koordinatları sıkıştırılır ve bir segment tree üzerinde kapsama sayıları tutulur. Böylece güncellemeler $O(\log n)$ sürer ve toplam karmaşıklık $O(n\log n)$ düzeyine yaklaşır.

Sweep line’ın asıl güzelliği burada saklıdır: Alanı doğrudan hesaplamaya çalışmak yerine, yalnızca değişimin gerçekleştiği koordinatlara bakarız. Geometri bir anda olaylar, aralıklar ve küçük şeritlerin toplamı hâline gelir.