``

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.

``

Sosyal ağı graf olarak düşünmek

Bir sosyal ağ $G=(V,E)$ grafıyla temsil edilir. $V$ kullanıcıları, $E$ ise arkadaşlık, takip veya mesajlaşma gibi ilişkileri gösterir. Her düğümün yaş, ilgi alanı ya da paylaşım sıklığı gibi bir özellik vektörü $x_v$ bulunabilir. Kenarlar da ilişkinin gücü veya türü gibi bilgiler taşıyabilir.

Klasik makine öğrenmesi kullanıcıları çoğunlukla bağımsız örnekler kabul eder. GNN ise “arkadaşının davranışı seni de anlatabilir” fikrinden hareket eder. Her düğüm, komşularından bilgi toplar ve kendi temsiliyle birleştirir. Bu işleme mesaj geçişi denir:

Burada $h_v^{(l)}$, $v$ düğümünün $l$. katmandaki temsilidir. $N(v)$ komşuları, $W_1$ ve $W_2$ öğrenilen ağırlıklar, $\sigma$ ise doğrusal olmayan aktivasyon fonksiyonudur. Birkaç katman sonunda düğüm yalnızca doğrudan arkadaşlarını değil, arkadaşlarının arkadaşlarını da özetleyen bir gömme (embedding) kazanır.

Geleneksel yöntem mi, GNN mi?

GNN doğrudan “topluluk numarası” üretmek zorunda değildir. Önce benzer düğümleri vektör uzayında yakınlaştırır, ardından K-Means gibi bir kümeleme algoritması bu temsilleri gruplandırabilir. Denetimli senaryoda ise bilinen birkaç topluluk etiketiyle düğüm sınıflandırması yapılabilir.

Küçük bir GCN uygulaması

Aşağıdaki model, PyTorch Geometric kullanarak düğümler için sekiz boyutlu temsiller üretir:

import torch
from torch_geometric.nn import GCNConv

class CommunityGCN(torch.nn.Module):
    def __init__(self, feature_count):
        super().__init__()
        self.conv1 = GCNConv(feature_count, 32)
        self.conv2 = GCNConv(32, 8)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index).relu()
        x = torch.nn.functional.dropout(
            x, p=0.3, training=self.training
        )
        return self.conv2(x, edge_index)

model = CommunityGCN(feature_count=16)
embeddings = model(data.x, data.edge_index)

data.x, kullanıcı özelliklerini içeren matrisi; data.edge_index ise bağlantıları gösterir. İlk GCN katmanı komşuluk bilgisini 32 boyutta işler. İkinci katman, kümelemeye verilebilecek sekiz boyutlu gömmeler oluşturur. Dropout, modelin belirli bağlantılara aşırı güvenmesini azaltır.

Etiketsiz eğitimde bağlantılı düğümlerin gömmelerini yakın, rastgele seçilen bağlantısız düğümleri uzak tutan bir kayıp kullanılabilir. Örneğin iki gömme arasındaki benzerlik $s(u,v)=z_u^Tz_v$ olarak tanımlanabilir. Model, gerçek kenarlarda yüksek; negatif örneklerde düşük skor üretmeyi öğrenir.

Başarıyı nasıl ölçeriz?

Gerçek topluluk etiketleri varsa NMI, ARI veya F1 skoru kullanılabilir. Etiket yoksa modülerlik, aynı topluluktaki bağlantı yoğunluğunu rastlantısal bir ağla karşılaştırır. Yüksek modülerlik iyi bir işaret olsa da tek başına kusursuzluk garantisi değildir; sosyal gruplar örtüşebilir ve kullanıcılar birden fazla topluluğa ait olabilir.

Son olarak gizlilik ve önyargı unutulmamalıdır. GNN, verideki ayrımcı desenleri de öğrenebilir. Bu yüzden anonimleştirme, adalet testleri ve açıklanabilirlik araçları teknik sürecin parçası olmalıdır. Doğru kullanıldığında GNN, bağlantı karmaşasını anlamlı sosyal haritalara dönüştüren oldukça güçlü bir pusuladı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.

``

Önce ortak düşman: Gereksiz karşılaştırmalar

Naif eşleştirmede uzunluğu $n$ olan metin ile uzunluğu $m$ olan desen için en kötü zaman karmaşıklığı $O(nm)$ olabilir. KMP ve Z-algoritması ise daha önce elde edilen eşleşme bilgisini yeniden kullanarak toplam süreyi

seviyesine indirir. Yani burada KMP gerçekten “çökmüyor”; başlıktaki çöküş, daha çok zihinsel yüküne yönelik küçük bir dramatizasyondur.

KMP neden zor hissediliyor?

KMP, desen için bir prefix tablosu üretir. Genellikle LPS veya $\pi$ dizisi denilen bu yapı, $\pi[i]$ konumunda desenin aynı zamanda suffix olan en uzun öz prefix’inin uzunluğunu saklar.

Örneğin ababaca deseninde eşleşme bozulduğunda başa dönmek yerine, prefix tablosu bize desenin hangi bölümünün hâlâ geçerli olduğunu söyler. Fikir güçlüdür; fakat tabloyu oluştururken kullanılan geri dönüş zinciri yeni başlayanları zorlayabilir:

while j > 0 and pattern[i] != pattern[j]:
    j = pi[j - 1]

Buradaki j = pi[j - 1] satırı algoritmanın kalbidir, ama “Neden tam olarak oraya dönüyoruz?” sorusu çoğu anlatımda havada kalır.

Z dizisinin daha görsel fikri

Bir dizge $S$ için $Z[i]$, S[i:] suffix’i ile bütün dizgenin prefix’i arasındaki en uzun ortak başlangıcın uzunluğudur:

Başka bir ifadeyle Z dizisi, her konumda “Buradan başlayan parça, dizgenin başına kaç karakter benziyor?” diye sorar. Metin eşleştirmek için desen ve metni bir ayraçla birleştiririz:

pattern#text

Bir konumdaki Z değeri desen uzunluğuna eşitse tam eşleşme bulmuşuzdur. # karakterinin desen veya metinde bulunmaması gerekir.

Orta düzey bir Python uygulaması

Aşağıdaki fonksiyon, daha önce hesaplanmış [left, right] eşleşme kutusunu kullanır. Böylece karakterler gereksiz yere tekrar karşılaştırılmaz:

def z_array(s):
    z = [0] * len(s)
    left = right = 0

    for i in range(1, len(s)):
        if i <= right:
            z[i] = min(right - i + 1, z[i - left])

        while i + z[i] < len(s) and s[z[i]] == s[i + z[i]]:
            z[i] += 1

        if i + z[i] - 1 > right:
            left, right = i, i + z[i] - 1

    return z


def find_matches(text, pattern):
    combined = pattern + "#" + text
    z = z_array(combined)
    offset = len(pattern) + 1
    return [i - offset for i, value in enumerate(z)
            if value == len(pattern)]

find_matches, eşleşmelerin metindeki başlangıç indekslerini döndürür. [left, right] aralığı bilinen bir prefix eşleşmesini temsil eder; z[i-left] ise bu hazır bilginin yeni konuma kopyalanabilecek kısmıdır.

Peki hangisini seçmeliyiz?

Metin karakter karakter akıyorsa ve birleşik dizge oluşturmak istemiyorsak KMP doğal bir seçimdir. Bellek davranışı öngörülebilirdir ve klasik arama senaryolarında son derece etkilidir. Buna karşılık tek bir dizgenin tekrarlarını, periyotlarını, border yapılarını veya birçok prefix eşleşmesini incelemek istiyorsak Z dizisi daha doğrudan sonuç verir.

Sonuç olarak Z-algoritması KMP’yi tahtından indirmez. İkisi de doğrusal zamanlıdır; fark, tuttukları bilginin bakış açısındadır. KMP eşleşme bozulduğunda geçmişi yönetir, Z ise her konumu başlangıçla karşılaştırır. Bazen en zarif algoritma daha hızlı olan değil, problemi zihnimizde en az düğümle anlatandı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.

``

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.