11.1 Çizge Terminolojisi

Bir çizge (graph), düğümlerden (nodes) ve kenarlardan (edges) oluşur. Bu yazıda $n$ çizgedeki toplam düğüm sayısını, $m$ ise toplam kenar sayısını belirtecektir. Düğümler $1, 2, \ldots, n$ tamsayılarıyla numaralandırılır.

Yol ve Döngü

Yol (path), $a$ düğümünden $b$ düğümüne kenarlar kullanılarak ulaşılmasını sağlar. Yolun uzunluğu, yolda geçilen kenar sayısına eşittir. Örneğin $1 \to 3 \to 4 \to 5$ yolu, 1. düğümden 5. düğüme 3 uzunluğunda bir yoldur.

Başlangıç ve son düğümün aynı olduğu yola döngü (cycle) denir. Bir yolda her düğüm en fazla bir kez geçiyorsa bu yol basittir (simple).

Bağlılık

Her iki düğümü arasında bir yol bulunan çizge bağlıdır (connected). Bir çizgenin bağlı alt gruplarına parça (component) denir. Örneğin ${1,2,3}$, ${4,5,6,7}$ ve ${8}$ olmak üzere üç parçalı bir çizge bağlı değildir.

Bir çizge bağlıysa ve $n$ düğüm ile $n-1$ kenardan oluşuyorsa bu çizge bir ağaçtır (tree). Ağaçta her iki düğüm arasında tam olarak bir yol vardır.

Kenar Yönleri

Kenarların tek yönlü olduğu çizge yönlüdür (directed). Yönlü bir çizgede $3 \to 1 \to 2 \to 5$ yolu olabilirken $5$’ten $3$’e giden herhangi bir yol olmayabilir.

Kenar Ağırlıkları

Ağırlıklı (weighted) bir çizgede her kenarın bir ağırlığı vardır; bu ağırlık genellikle uzunluk olarak yorumlanır. Ağırlıklı bir çizgedeki yolun uzunluğu, yoldaki kenarların ağırlıklarının toplamıdır. Örneğin $1 \to 2 \to 5$ yolunun uzunluğu 12, $1 \to 3 \to 4 \to 5$ yolunun uzunluğu 11 olabilir; burada ikinci yol daha kısadır.

Komşular ve Dereceler

İki düğüm arasında kenar varsa bunlar komşu (neighbor) düğümlerdir. Bir düğümün derecesi (degree), komşu sayısına eşittir.

$m$ kenarlı bir çizgenin toplam derece sayısı her zaman $2m$’dir; çünkü her kenar iki düğümün derecesini birer artırır. Bu nedenle derece toplamı daima çifttir.

Yönlü çizgelerde bir düğümün iç derecesi (indegree) o düğüme gelen kenar sayısını, dış derecesi (outdegree) ise o düğümden çıkan kenar sayısını verir.

Her düğümün derecesi $d$ ise çizge sıradan (regular), her düğüm birbirine bağlıysa (derece $n-1$) çizge tam (complete) olarak adlandırılır.

Boyamalar

Çizgeyi boyarken komşu düğümlerin farklı renk almasına dikkat edilir. Yalnızca iki renkle boyanabilen çizge iki parçalıdır (bipartite). Bir çizgenin iki parçalı olabilmesi için tek sayıda kenarlı herhangi bir döngü içermemesi gerekir.

Örneğin altı düğümlü bir çizge iki parçalıysa düğümler iki gruba ayrılıp her kenar gruplar arasında geçer; iki renkle boyanabilir. Ama tek sayıda kenarlı bir döngü içeriyorsa boyama mümkün olmaz.

Genel durumda bir çizgenin $k$ renkle boyanıp boyanamayacağını bulmak zordur. $k = 3$ için dahi bilinen verimli bir algoritma yoktur — bu problem NP-hard‘dır.

Basitlik

Aynı düğümde başlayıp biten kenar (öz-döngü) veya iki düğüm arasında birden fazla kenar içeren çizge basit değildir (not simple). Genellikle çizgelerin basit olduğu kabul edilir.

11.2 Çizge Gösterimi

Algoritmalarda çizgeleri göstermenin birkaç yaygın yolu vardır. Veri yapısının seçimi çizgenin büyüklüğüne ve algoritmanın çizgeyi işleme biçimine göre değişir.

Komşuluk Listesi Gösterimi

Komşuluk listesi (adjacency list) gösteriminde her $x$ düğümüne bir liste atanır; bu liste $x$’ten çıkan kenarların ulaştığı düğümleri içerir. Komşuluk listeleri çizgeleri göstermenin en popüler yoludur ve çoğu algoritma bu yöntemle verimli biçimde kodlanabilir.

Komşuluk listesini oluşturmanın pratik yolu vektörlerden oluşan bir dizi kullanmaktır:

vector<int> adj[N];

Örneğin aşağıdaki çizge için:

adj[1].push_back(2);
adj[2].push_back(3);
adj[2].push_back(4);
adj[3].push_back(4);
adj[4].push_back(1);

Yönsüz (undirected) çizgelerde her kenar her iki yöne de eklenir. Ağırlıklı bir çizge için yapı şöyle güncellenir:

vector<pair<int,int>> adj[N];

Bu durumda $a$ düğümünden $b$ düğümüne $w$ ağırlığında kenar varsa $a$’nın listesi $(b, w)$ çiftini içerir:

adj[1].push_back({2, 5});
adj[2].push_back({3, 7});
adj[2].push_back({4, 6});
adj[3].push_back({4, 5});
adj[4].push_back({1, 2});

Komşuluk listesinin en büyük avantajı, bir düğümden ulaşılabilecek düğümlerin hızlıca dolaşılabilmesidir:

for (auto u : adj[s]) {
    // u düğümünü işle
}

Komşuluk Matrisi Gösterimi

Komşuluk matrisi (adjacency matrix) gösterimi, çizgedeki kenarları iki boyutlu bir dizide tutar ve iki düğüm arasında kenar olup olmadığını $O(1)$ zamanda sorgular:

int adj[N][N];

adj[a][b] = 1 ise $a$’dan $b$’ye kenar vardır, adj[a][b] = 0 ise yoktur. Ağırlıklı çizgelerde kenar ağırlığı da bu matriste tutulabilir.

Dezavantajı, $n^2$ elemanlık bir dizi gerektirmesidir. Büyük çizgeler için bellek açısından pratik değildir; özellikle matrisin büyük bölümü sıfırdan oluştuğunda (seyrek çizgeler).

Kenar Listesi Gösterimi

Kenar listesi (edge list) gösterimi, çizgenin tüm kenarlarını rastgele bir sırada bir vektörde tutar. Algoritma tüm kenarları işliyorsa ve belirli bir düğümden başlayan kenarları bulmaya gerek yoksa bu gösterim uygundur.

vector<pair<int,int>> edges;

Her $(a, b)$ çifti, $a$ düğümünden $b$ düğümüne bir kenar olduğunu gösterir:

edges.push_back({1, 2});
edges.push_back({2, 3});
edges.push_back({2, 4});
edges.push_back({3, 4});
edges.push_back({4, 1});

Ağırlıklı çizgeler için yapı üçlü demet olarak genişletilir:

vector<tuple<int,int,int>> edges;

Her $(a, b, w)$ demeti, $a$’dan $b$’ye $w$ ağırlığında kenar olduğunu belirtir¹:

edges.push_back({1, 2, 5});
edges.push_back({2, 3, 7});
edges.push_back({2, 4, 6});
edges.push_back({3, 4, 5});
edges.push_back({4, 1, 2});

Gösterimler Arasında Karşılaştırma

Seyrek çizgelerde ($m \ll n^2$) komşuluk listesi tercih edilir. Yoğun çizgelerde ($m \approx n^2$) komşuluk matrisi pratik olabilir. Bellman-Ford gibi tüm kenarları tek tek işleyen algoritmalar için kenar listesi doğal bir seçimdir.

• sumq(a, b): $[a, b]$ aralığındaki sayıların toplamını bul
• minq(a, b): $[a, b]$ aralığındaki minimum sayıyı bul
• maxq(a, b): $[a, b]$ aralığındaki maksimum sayıyı bul

Örneğin [1, 3, 8, 4, 6, 1, 3, 4] dizisinde $[3,6]$ aralığı için sumq(3,6) = 14, minq(3,6) = 1, maxq(3,6) = 6 olur.

En basit yaklaşım aralık içindeki tüm elemanlara tek tek bakmaktır; bu $O(n)$ sürer. $q$ sorgu için toplam $O(nq)$ zaman gerekir. Hem $n$ hem de $q$ büyük olduğunda bu yavaş kalır. Neyse ki aralık sorgularını çok daha verimli yapmanın yolları vardır.

9.1 Statik Dizi Sorguları

Dizinin statik olduğu (sorgular sırasında değerlerin değişmediği) duruma ilk bakacağız. Bu durumda sorguları sabit zamanda yanıtlayan bir veri yapısı oluşturmak yeterlidir.

Toplam Sorguları

Statik bir dizideki toplam sorgularını prefix toplam dizisi ile kolayca çözebiliriz. Prefix toplam dizisindeki $k$. konum, orijinal dizinin $[0, k]$ aralığının toplamına eşittir; yani sumq(0, k) değerini tutar. Bu dizi $O(n)$ zamanda oluşturulabilir.

Örneğin [1, 3, 4, 8, 6, 1, 4, 2] dizisine karşılık gelen prefix toplam dizisi:

1  4  8  16  22  23  27  29
0  1  2   3   4   5   6   7

Herhangi bir sumq(a, b) değerini $O(1)$ zamanda şu formülle bulabiliriz:

$\text{sumq}(0, -1) = 0$ tanımlaması sayesinde formül $a = 0$ için de geçerlidir. Örneğin:

Bu fikir daha fazla boyuta da genelleşir. İki boyutlu bir prefix toplam dizisi oluşturularak herhangi bir dikdörtgen alt dizi toplamı $O(1)$ zamanda hesaplanabilir. Gri alt dizinin toplamı, $S(X)$’in sol üst köşeden $X$ pozisyonuna gelen dikdörtgen alt dizi toplamı olduğu varsayılarak şu formülle bulunur:

Minimum Sorgular

Minimum sorgular, toplam sorgularına göre daha zordur. Yine de $O(n \log n)$’lik bir ön işleme ile minimum sorguları $O(1)$ zamanda yanıtlanabilir¹. Minimum ve maksimum sorgular benzer şekilde ele alındığından yalnızca minimuma bakacağız.

Fikir: Uzunluğu ikinin kuvveti olan tüm minq(a, b) değerleri önceden hesaplanır. Örneğin [1, 3, 4, 8, 6, 1, 4, 2] dizisi için bu değerler uzunluk 1, 2 ve 4’lük aralıklar için aşağıdaki gibidir:

Toplam $O(n \log n)$ değer, aşağıdaki özyinelemeli formülle hesaplanır ($w = (b - a + 1)/2$):

Sorgu anında $b - a + 1$ değerini geçmeyen en büyük ikinin kuvveti $k$ alınır ve:

formülü $O(1)$ zamanda sonucu verir. Örneğin $[1, 6]$ aralığında uzunluk 6 için $k = 4$ seçilir; $[1,4]$ ve $[3,6]$ aralıklarının birleşimi olarak $\text{minq}(1,6) = \min(3, 1) = 1$ bulunur.

9.2 İkili İndisli Ağaç (Binary Indexed Tree)

İkili indisli ağaç ya da Fenwick ağacı², prefix toplam dizisinin dinamik versiyonu olarak düşünülebilir. $O(\log n)$ zamanda iki operasyonu destekler: aralık toplamı sorgusu ve tek eleman güncellemesi. Prefix toplam dizisinden farkı, her güncellemeden sonra diziyi baştan oluşturmak yerine yalnızca ilgili konumları güncellemesidir.

Yapı

Bu bölümde diziler 1’den indislenir. $p(k)$, $k$’yı tam bölen en büyük 2’nin kuvveti olsun. İkili indisli ağaç tree dizisinde şu şekilde tutulur:

Yani her $k$ konumu, uzunluğu $p(k)$ olan ve $k$’da biten aralığın toplamını tutar. Örneğin $p(6) = 2$ olduğundan tree[6], sumq(5, 6) değerini saklar.

[1, 3, 4, 8, 6, 1, 4, 2] dizisine karşılık gelen ikili indisli ağaç:

1  4  4  16  6  7  4  29
1  2  3   4  5  6  7   8

$[1, k]$ aralığı her zaman ağaçta toplamları tutulan $O(\log n)$ alt aralığa bölünebildiğinden sumq(1, k) değeri $O(\log n)$ zamanda hesaplanabilir. Örneğin:

$a > 1$ durumunda ise:

İmplementasyon

İkili indisli ağaç, bit operasyonları kullanılarak verimli biçimde kodlanabilir. $p(k)$ değeri şöyle hesaplanır:

sumq(1, k) değerini hesaplayan fonksiyon:

int sum(int k) {
    int s = 0;
    while (k >= 1) {
        s += tree[k];
        k -= k & -k;
    }
    return s;
}

$k$. pozisyondaki elemanı $x$ kadar artıran fonksiyon:

void add(int k, int x) {
    while (k <= n) {
        tree[k] += x;
        k += k & -k;
    }
}

Her iki fonksiyon da $O(\log n)$ zamanda çalışır; her adımda $O(\log n)$ farklı konuma erişilir ve her hareket $O(1)$ zaman alır.

9.3 Segment Ağacı

Segment ağacı³ iki operasyonu destekleyen genel amaçlı bir veri yapısıdır: aralık sorgusu ve tek eleman güncellemesi. İkili indisli ağaca kıyasla daha geneldir; yalnızca toplam değil minimum, maksimum, EBOB, bit operasyonları (AND, OR, XOR) gibi pek çok sorguyu da $O(\log n)$ zamanda destekler. Bununla birlikte daha fazla bellek kullanır ve implementasyonu biraz daha karmaşıktır⁴.

Yapı

Segment ağacı bir ikili ağaçtır; en alt seviyedeki yapraklar dizi elemanlarına, iç düğümler ise aralık sorgularına gereken bilgilere karşılık gelir. Dizinin boyutunun ikinin kuvveti olduğu ve sıfır tabanlı indis kullanıldığı varsayılır; gerekirse fazladan eleman eklenebilir.

Toplam sorgularını destekleyen [5, 8, 6, 3, 2, 7, 2, 6] dizisine karşılık gelen segment ağacı:

           39
       22      17
    13    9   9   8
   5 8  6 3  2 7 2 6

Her iç düğüm, kendisine karşılık gelen aralığın elemanlarının toplamını tutar ve bu değer sol ile sağ çocuklarının toplamına eşittir.

Herhangi bir $[a, b]$ aralığı, değerleri ağaç düğümlerinde bulunan $O(\log n)$ alt aralığa bölünebilir. Örneğin $[2, 7]$ aralığı için sumq(2,7) = 9 + 17 = 26. Her seviyeden en fazla iki düğüm kullanıldığından toplam düğüm sayısı $O(\log n)$ olur.

Bir dizi güncellemesinden sonra değişen düğümdeki yapraktan köke giden yoldaki tüm iç düğümler güncellenir; bu yol $O(\log n)$ düğüm içerir.

İmplementasyon

Segment ağacı, $n$ elemanlı bir dizi için $2n$ elemanlı bir dizi içinde tutulur. tree[1] köke, tree[2] ve tree[3] köke bağlı çocuklara karşılık gelir. tree[n]‘den tree[2n-1]‘e kadar olan değerler yaprak düğümlerdir.

39 22 17 13  9  9  8  5  8  6  3  2  7  2  6
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Bu gösterimde tree[k]‘nin ebeveyni tree[⌊k/2⌋], çocukları tree[2k] ve tree[2k+1] olur.

sumq(a, b) değerini hesaplayan fonksiyon:

int sum(int a, int b) {
    a += n; b += n;
    int s = 0;
    while (a <= b) {
        if (a % 2 == 1) s += tree[a++];
        if (b % 2 == 0) s += tree[b--];
        a /= 2; b /= 2;
    }
    return s;
}

$k$. pozisyondaki elemanı $x$ kadar artıran fonksiyon:

void add(int k, int x) {
    k += n;
    tree[k] += x;
    for (k /= 2; k >= 1; k /= 2) {
        tree[k] = tree[2*k] + tree[2*k+1];
    }
}

Her iki fonksiyon da $O(\log n)$ zamanda çalışır.

Diğer Sorgular

Segment ağaçları, bir aralığı iki parçaya bölmenin mümkün olduğu tüm sorgular için kullanılabilir: minimum/maksimum, EBOB, AND/OR/XOR gibi bit operasyonları. Örneğin minimum sorgularını destekleyen ağaçta her düğüm, ilgili aralığın minimumunu tutar.

Segment ağacının ikili ağaç yapısı, ikili arama uygulamasına da olanak tanır. Örneğin minimum sorgularını destekleyen bir ağaçta en küçük değere sahip eleman $O(\log n)$ zamanda bulunabilir; kökten yapraklara doğru inen yolda minimum değer izlenerek bu eleman tespit edilir.

9.4 Ek Teknikler

İndis Sıkıştırması

Bu bölümdeki veri yapıları ardışık sayılardan oluşan diziler üzerine kuruludur. Büyük indisler gerektiğinde (örneğin $10^9$ indisi) bellek yetersizliği sorunu ortaya çıkar. Bu sınır indis sıkıştırması ile aşılabilir.

Buradaki fikir, orijinal indisleri $1, 2, 3, \ldots$ gibi ardışık indislerle değiştirmektir. Bunun için algoritma çalışmaya başlamadan önce tüm indislerin bilinmesi gerekir. Sıkıştırma fonksiyonu $c$ sıralamayı korumalıdır: eğer $a < b$ ise $c(a) < c(b)$ olmalıdır. Bu sayede indisler sıkıştırılmış olsa bile sorgular doğru çalışır.

Örneğin orijinal indisler $8$, $555$ ve $10^9$ ise yeni indisler:

Aralık Güncellemeleri

Şimdiye kadar aralık sorguları yapıp tek eleman güncelleyebilen yapılar incelendi. Tam tersi durumda — aralık güncelleyip tek eleman okumada — fark dizisi kullanılır. Fark dizisindeki her değer, mevcut değer ile orijinal değer arasındaki farkı tutar; dolayısıyla orijinal dizi, fark dizisinin prefix toplam dizisidir.

Örneğin [3, 3, 1, 1, 1, 5, 2, 2] dizisinin fark dizisi:

3  0  -2  0  0  4  -3  0
0  1   2  3  4  5   6  7

Fark dizisinin avantajı, orijinal dizideki bir aralığı yalnızca iki elemanı değiştirerek güncelleyebilmesidir. Örneğin $[1, 4]$ aralığındaki tüm değerleri 5 artırmak için fark dizisindeki 1. konumu 5 artırıp 5. konumu 5 azaltmak yeterlidir:

Genel olarak $[a, b]$ aralığını $x$ kadar artırmak için $a$. konumu $x$ artırıp $b+1$. konumu $x$ azaltırız. Tek eleman güncellemesi ve toplam sorgusunun birlikte gerektiği bu yapı için ikili indisli ağaç veya segment ağacı kullanılır.

Hem aralık sorgularını hem de aralık güncellemelerini bir arada destekleyen daha gelişmiş yapılar Bölüm 28’de ele alınacaktır.

10.1 Bit Gösterimi

Programlamada bir $n$ bitlik tamsayı, $n$ bitten oluşan bir binary sayısı olarak tutulur. Örneğin C++’da int 32-bit olup her int sayısı 32 bitten oluşur.

int 43 sayısının bit gösterimi:

00000000000000000000000000101011

Gösterimdeki bitler sağdan sola sıralanır. Bit gösterimi $b_k \cdots b_2 b_1 b_0$ olan bir sayıya dönüştürmek için:

Örneğin $1 \cdot 2^5 + 1 \cdot 2^3 + 1 \cdot 2^1 + 1 \cdot 2^0 = 43$.

Signed ve Unsigned Gösterim

Bir sayının bit gösterimi ya signed ya da unsigned olur.

Signed gösterimde hem negatif hem pozitif sayılar tutulabilir. $n$ bitlik bir signed değişken $-2^{n-1}$ ile $2^{n-1}-1$ arasındaki herhangi bir tamsayıyı tutabilir. C++’da int signed’dır; $-2^{31}$ ile $2^{31}-1$ arasındaki değerleri alabilir. Signed gösterimde ilk bit işaret bitidir (negatif olmayan sayılar için 0, negatifler için 1). Negatifler ikinin tümleyeni (Two’s Complement) ile gösterilir: tüm bitler tersine çevrilir ve 1 eklenir. Örneğin int -43 sayısının bit gösterimi:

11111111111111111111111111010101

Unsigned gösterimde yalnızca negatif olmayan sayılar kullanılır; buna karşın üst sınır daha yüksektir. $n$ bitlik bir unsigned değişken $0$ ile $2^n - 1$ arasındaki değerleri tutabilir. C++’da unsigned int değişkeni $0$ ile $2^{32}-1$ arasında olabilir.

İki gösterim arasındaki ilişki: bir signed sayı $-x$, unsigned sayı $2^n - x$’e eşittir.

int x = -43;
unsigned int y = x;
cout << x << "\n"; // -43
cout << y << "\n"; // 4294967253

Overflow

Bir sayı bit gösteriminin üst sınırını aşarsa overflow oluşur. Signed gösterimde $2^{n-1}-1$’den sonraki sayı $-2^{n-1}$ olur; unsigned gösterimde $2^n - 1$’den sonraki sayı $0$ olur.

int x = 2147483647; // 2^31 - 1
x++;
cout << x << "\n"; // -2147483648

10.2 Bit Operasyonları

Ve (AND) Operasyonu

x & y, hem $x$’te hem $y$’de 1 olan bitlerde 1, diğerlerinde 0 içerir. Örneğin $22\ \&\ 26 = 18$:

  10110  (22)
& 11010  (26)
= 10010  (18)

AND operasyonu ile bir $x$ sayısının çift olup olmadığını kontrol edebiliriz: $x$ çiftse x & 1 = 0, tekse x & 1 = 1. Genel olarak x & (2^k - 1) = 0 ise $x$, $2^k$’ya bölünebiliyordur.

Veya (OR) Operasyonu

  10110  (22)
| 11010  (26)
= 11110  (30)

XOR Operasyonu

x ^ y, $x$ ya da $y$’den yalnızca birinde 1 bulunan pozisyonlarda 1 içerir. Örneğin $22\ \hat{}\ 26 = 12$:

  10110  (22)
^ 11010  (26)
= 01100  (12)

Ters (NOT) Operasyonu

~x, $x$’in tüm bitlerini tersine çevirir. $\sim x = -x - 1$ formülü geçerlidir. Örneğin ~29 = -30. 32-bit int için:

 x =  29   00000000000000000000000000011101
~x = -30   11111111111111111111111111100010

Bit Kaydırması

Sol kaydırma x << k, sayıya $k$ tane 0 biti ekler ($x \cdot 2^k$). Sağ kaydırma x >> k, sayıdan son $k$ biti çıkarır ($\lfloor x / 2^k \rfloor$). Örneğin $14 \ll 2 = 56$ (1110 → 111000) ve $49 \gg 3 = 6$ (110001 → 110).

Uygulamalar

1 << k formundaki sayı, yalnızca $k$. pozisyonda 1 biti içerir; bu sayede tek bitlere erişebiliriz. $x$’in $k$. biti, x & (1 << k) sıfır olmadığında 1’dir. Aşağıdaki kod bir int x sayısının bit gösterimini yazdırır:

for (int i = 31; i >= 0; i--) {
    if (x & (1 << i)) cout << "1";
    else cout << "0";
}

Benzer fikirlerle bitleri değiştirmek de mümkündür:

x & (x-1) = 0 ise $x$ pozitif sayısı ikinin kuvvetidir.

g++ Yerleşik Fonksiyonları

g++ derleyicisi bit sayımı için hazır fonksiyonlar sunar:

int x = 5328; // 00000000000000000000010100110100000
cout << __builtin_clz(x)      << "\n"; // 19  (baştaki 0 sayısı)
cout << __builtin_ctz(x)      << "\n"; // 4   (sondaki 0 sayısı)
cout << __builtin_popcount(x) << "\n"; // 5   (1 bit sayısı)
cout << __builtin_parity(x)   << "\n"; // 1   (1 bitlerinin tek/çift paritesi)

long long sayılar için aynı fonksiyonların ll ön ekli versiyonları kullanılır: __builtin_popcountll vb.

10.3 Kümeleri Göstermek

${0, 1, 2, \ldots, n-1}$ kümesinin her alt kümesi, $n$ bitten oluşan bir tamsayıyla gösterilebilir. 1 bitleri alt kümeye ait elemanları belirtir. Bu yöntem son derece verimlidir: her eleman yalnızca bir bit hafıza gerektirir ve küme operasyonları doğrudan bit operasyonlarına dönüşür.

Örneğin int 32-bit olduğundan bir int sayısı, ${0, 1, \ldots, 31}$ kümesinin herhangi bir alt kümesini gösterebilir. ${1, 3, 4, 8}$ kümesinin bit gösterimi:

00000000000000000000000100011010

Bu $2^8 + 2^4 + 2^3 + 2^1 = 282$ sayısına karşılık gelir.

Küme İmplementasyonu

int x = 0;
x |= (1 << 1);  // {1}
x |= (1 << 3);  // {1, 3}
x |= (1 << 4);  // {1, 3, 4}
x |= (1 << 8);  // {1, 3, 4, 8}
cout << __builtin_popcount(x) << "\n"; // 4

Kümeye ait elemanları yazdırmak:

for (int i = 0; i < 32; i++) {
    if (x & (1 << i)) cout << i << " ";
}
// çıktı: 1 3 4 8

Küme Operasyonları

Örneğin $x = {1,3,4,8}$ ve $y = {3,6,8,9}$ için birleşim $z = x \cup y = {1,3,4,6,8,9}$:

int x = (1<<1)|(1<<3)|(1<<4)|(1<<8);
int y = (1<<3)|(1<<6)|(1<<8)|(1<<9);
int z = x | y;
cout << __builtin_popcount(z) << "\n"; // 6

Altkümelerden Geçmek

${0, 1, \ldots, n-1}$ kümesinin tüm alt kümelerinden geçmek:

for (int b = 0; b < (1 << n); b++) {
    // b alt kümesini işle
}

Tam $k$ elemanlı alt kümelerden geçmek:

for (int b = 0; b < (1 << n); b++) {
    if (__builtin_popcount(b) == k) {
        // b alt kümesini işle
    }
}

Bir $x$ kümesinin tüm alt kümelerinden geçmek:

int b = 0;
do {
    // b alt kümesini işle
} while (b = (b - x) & x);

10.4 Bit Optimizasyonu

Çoğu algoritma bit operasyonları ile optimize edilebilir. Bu optimizasyonlar zaman karmaşıklığını değiştirmez; ancak gerçek çalışma süresinde büyük fark yaratabilir.

Hamming Mesafeleri

Hamming mesafesi $\text{hamming}(a, b)$, eşit uzunluktaki $a$ ve $b$ yazılarının farklı olduğu konum sayısıdır. Örneğin $\text{hamming}(01101,\ 11001) = 2$.

Her biri $k$ uzunluğunda $n$ adet bit yazısından oluşan bir listede minimum Hamming mesafesini bulmak istersek naif çözüm $O(n^2 k)$ sürer:

int hamming(string a, string b) {
    int d = 0;
    for (int i = 0; i < k; i++) {
        if (a[i] != b[i]) d++;
    }
    return d;
}

$k \leq 32$ ise yazıları int olarak tutup XOR + popcount ile çok daha hızlı hesaplayabiliriz:

int hamming(int a, int b) {
    return __builtin_popcount(a ^ b);
}

XOR operasyonu, $a$ ve $b$’nin farklı olduğu pozisyonlarda 1 içeren bir sayı üretir; __builtin_popcount ise bu 1 bitlerini sayar.

30 uzunluğundaki 10.000 rastgele bit yazısından oluşan bir listede bu iki yaklaşım karşılaştırılmış; naif yöntem 13.5 saniye, bit optimize versiyonu ise yalnızca 0.5 saniye sürmüştür. Yaklaşık 27 kat hızlanma.

Alt Izgaraları Saymak

$n \times n$’lik bir ızgarada her kare ya siyah (1) ya da beyaz (0) olsun. Tüm köşeleri siyah olan alt ızgara sayısını bulmak istiyoruz.

Naif $O(n^3)$ çözümde tüm $O(n^2)$ satır çifti $(a, b)$ için her iki satırda aynı anda siyah olan sütunları sayıp $\binom{\text{count}}{2}$ ile çarpıyoruz:

int count = 0;
for (int i = 0; i < n; i++) {
    if (color[a][i] == 1 && color[b][i] == 1) count++;
}

Bit optimizasyonunda ızgarayı $N$ sütunluk bloklara bölüp her satırı $N$-bitlik tamsayı listesi olarak tutarız. Böylece $N$ sütunu aynı anda AND + popcount ile işleyebiliriz:

int count = 0;
for (int i = 0; i <= n / N; i++) {
    count += __builtin_popcount(color[a][i] & color[b][i]);
}

Bu sayede algoritma $O(n^3/N)$ zamana düşer. $2500 \times 2500$ rastgele ızgarada yapılan karşılaştırmada: orijinal kod 29.6 saniye, $N=32$ (int) ile 3.1 saniye, $N=64$ (long long) ile 1.7 saniye sürmüştür.

10.5 Dinamik Programlama

Bit operasyonları, elemanların alt kümelerini içeren dinamik programlama algoritmalarını hem verimli hem de temiz biçimde yazmamızı sağlar; çünkü durumları birer sayı olarak tutabiliriz.

Optimal Seçim

$k$ ürünün $n$ gündeki fiyatları verildiğinde her ürünü tam bir kez ve günde en fazla bir ürün alarak minimum toplam ücret nedir?

$\text{price}[x][d]$, $x$ ürününün $d$. gündeki fiyatı olsun. $\text{total}(S, d)$ ise $S$ alt kümesindeki ürünleri $d$. güne kadar almayı sağlayan minimum toplam ücret olsun. Hedef $\text{total}({0 \ldots k-1},\ n-1)$ değeridir.

Temel durumlar: $\text{total}(\emptyset, d) = 0$ ve $\text{total}({x}, 0) = \text{price}[x][0]$. Genel özyineleme:

Dinamik programlama ile implementasyon:

int total[1 << K][N];

// d = 0 başlangıç durumları
for (int x = 0; x < k; x++) {
    total[1 << x][0] = price[x][0];
}

// DP geçişi
for (int d = 1; d < n; d++) {
    for (int s = 0; s < (1 << k); s++) {
        total[s][d] = total[s][d - 1];
        for (int x = 0; x < k; x++) {
            if (s & (1 << x)) {
                total[s][d] = min(total[s][d],
                    total[s ^ (1 << x)][d - 1] + price[x][d]);
            }
        }
    }
}

Algoritmanın zaman karmaşıklığı $O(n \cdot 2^k \cdot k)$ olur.

Permütasyonlardan Altkümelere

Permütasyonlar yerine altkümelere bakmak büyük avantaj sağlayabilir: $n = 20$ için $n! \approx 2.4 \times 10^{18}$ iken $2^n \approx 10^6$’dır¹.

Örnek problem: Maksimum kapasitesi $x$ olan bir asansörle $n$ insanı en az kaç turda taşıyabiliriz?

$\text{rides}(S)$ = $S$ alt kümesini taşımak için gereken minimum tur sayısı, $\text{last}(S)$ = son turdaki minimum toplam ağırlık olsun. Hedef $\text{rides}({0 \ldots n-1})$.

pair<int,int> best[1 << N];
best[0] = {1, 0};

for (int s = 1; s < (1 << n); s++) {
    best[s] = {n + 1, 0};
    for (int p = 0; p < n; p++) {
        if (s & (1 << p)) {
            auto option = best[s ^ (1 << p)];
            if (option.second + weight[p] <= x) {
                // p'yi mevcut tura ekle
                option.second += weight[p];
            } else {
                // p için yeni tur oluştur
                option.first++;
                option.second = weight[p];
            }
            best[s] = min(best[s], option);
        }
    }
}

Döngü, $S_1 \subseteq S_2$ olduğunda $S_1$’i her zaman $S_2$’den önce işler; bu sayede DP değerleri doğru sırada hesaplanır. Zaman karmaşıklığı $O(2^n \cdot n)$.

Altkümeleri Saymak

Her $S \subseteq X$ alt kümesi için bir $\text{value}[S]$ tamsayısı tanımlansın. Her $S$ için alt kümelerinin değer toplamını hesaplamak istiyoruz:

Naif çözüm tüm $O(2^{2n})$ alt küme çiftlerini dener. Daha akıllı yaklaşım için $\text{partial}(S, k)$, $S$’ten yalnızca $0 \ldots k$ elemanlarının çıkarılabildiği durumdaki toplamı versin:

$\text{sum}(S) = \text{partial}(S, n-1)$ olduğundan dinamik programlama ile aşağıdaki $O(2^n \cdot n)$ implementasyon elde edilir:

int sum[1 << N];

for (int s = 0; s < (1 << n); s++) {
    sum[s] = value[s];
}

for (int k = 0; k < n; k++) {
    for (int s = 0; s < (1 << n); s++) {
        if (s & (1 << k)) sum[s] += sum[s ^ (1 << k)];
    }
}

Her $k$ adımında sum dizisi yeniden kullanılır; böyle verimli ve sade bir implementasyon elde edilir.

Amortize Analizi, zaman karmaşıklığı farklı olan operasyonları içeren algoritmaları inceler. Buradaki fikir, tek tek operasyonların en kötü durumuna bakmak yerine, algoritmanın çalışması sürecinde bütün operasyonlar için harcanan toplam zamanı tahmin etmektir. Bazen bazı operasyonlar yavaş olsa da, toplamda bu yavaş operasyonlar sık gerçekleşmediği için ortalama performans verimli olabilir.

8.1 İki İşaretçi Methodu (Two Pointers Method)

İki işaretçi methodunda, dizinin elemanları üzerinden geçmek için iki işaretçi (pointer) kullanılır. Bu işaretçiler genellikle tek bir yöne doğru hareket ederler, bu da algoritmanın verimli çalışmasını sağlar.

Altdizi (Subarray) Toplamı

Problem: n tane pozitif sayıdan oluşan bir dizide, toplamı x olan ardışık bir altdizi bulmak.

Fikir: Altdizinin başlangıcını ve sonunu gösteren iki işaretçi (sol ve sağ) tutulur. sağ işaretçi, toplam x‘i geçmediği sürece ilerletilir. Toplam x‘i geçerse, sol işaretçi ilerletilerek altdizi küçültülür. Eğer toplam tam olarak x olursa, bir çözüm bulunmuş olur.

[1, 3, 2, 5, 1, 1, 2, 3] dizisinde toplamı 8 olan altdiziyi bulmak için iki işaretçi yönteminin adımları

Her iki işaretçi de dizi boyunca sadece ileri doğru hareket ettiği için toplamda en fazla 2n adım atarlar. Bu yüzden algoritma $O(n)$ zamanda çalışır.

2SUM Problemi

Problem: n sayıdan oluşan bir dizide, toplamı x olan iki eleman bulmak.

Fikir:

1. Diziyi artan sırada sıralayın.
2. Bir işaretçiyi (sol) dizinin başına, diğerini (sağ) dizinin sonuna yerleştirin.
3. array[sol] + array[sağ] toplamını kontrol edin:
   • Toplam x‘ten küçükse, daha büyük bir değere ihtiyacımız var demektir, bu yüzden sol işaretçisini bir sağa kaydırın.
   • Toplam x‘ten büyükse, daha küçük bir değere ihtiyacımız var demektir, bu yüzden sağ işaretçisini bir sola kaydırın.
   • Toplam x‘e eşitse, bir çözüm bulunmuştur.
4. İşaretçiler karşılaşana kadar devam edin.

Sıralama $O(n \log n)$, iki işaretçi ile arama ise $O(n)$ sürdüğü için toplam zaman karmaşıklığı $O(n \log n)$ olur. Daha zor bir problem olan 3SUM problemi (toplamı x olan üç eleman bulmak), bu fikir genişletilerek $O(n^2)$ zamanda çözülebilir¹.

8.2 En Yakın Küçük Elemanlar (Nearest Smaller Elements)

Problem: Bir dizideki her eleman için, o elemanın solunda bulunan ve kendisinden küçük olan en yakın elemanı bulmak.

Fikir: Dizinin solundan sağına doğru ilerlerken bir yığın (stack) kullanılır. Her eleman için:

1. Yığının tepesindeki eleman mevcut elemandan küçük olana kadar veya yığın boşalana kadar yığından eleman çıkarılır.
2. Eğer yığın boş değilse, tepedeki eleman aranan en yakın küçük elemandır.
3. Mevcut eleman yığına eklenir.

[1, 3, 4, 2, 5, 3, 4, 2] dizisi için yığının adım adım değişimi

Bir eleman yığına en fazla bir kez eklenip bir kez çıkarıldığı için, her eleman amortize olarak $O(1)$ yığın operasyonu gerektirir. Bu yüzden algoritmanın toplam zaman karmaşıklığı $O(n)$’dir.

8.3 Sürgülü Pencere Minimumu (Sliding Window Minimum)

Problem: Sabit k boyutundaki bir altdizinin (sürgülü pencere), dizi boyunca soldan sağa hareket ederken her pozisyondaki minimum elemanı bulmak.

Fikir: Bir deque (çift yönlü kuyruk) veri yapısı kullanılır. Bu deque her zaman pencere içindeki elemanların indislerini artan değer sırasında tutar. deque‘in başındaki eleman her zaman o anki pencerenin minimumudur. Her adımda pencere bir sağa kaydığında:

1. deque‘in sonundan, yeni eklenecek elemandan daha büyük olan elemanlar çıkarılır.
2. Yeni elemanın indisi deque‘in sonuna eklenir.
3. deque‘in başındaki elemanın indisi pencerenin dışına çıkmışsa, baştan çıkarılır.

Her eleman deque‘e en fazla bir kez eklenip bir kez çıkarıldığı için, bu algoritma da amortize olarak $O(n)$ zamanda çalışır.

Dinamik programlamanın iki temel kullanımı vardır:

• Optimal bir çözüm bulmak: Olabildiğince büyük veya küçük bir sonuç aradığımız durumlar.
• Olası çözüm sayısını hesaplamak: Toplam olası çözüm sayısını bulmak.

Bu bölüm, dinamik programlamanın temellerini ve klasik problemler üzerindeki uygulamalarını gösterecektir.

7.1 Para Problemi

Bölüm 6’da gördüğümüz para problemini tekrar ele alalım: coins = {c_1, c_2, ..., c_k} değerlerinden oluşan bir para kümesiyle, n toplamını oluşturan en az sayıda parayı bulmak. Açgözlü yaklaşımın her zaman çalışmadığını görmüştük. Şimdi bu problemi her para kümesi için çalışan dinamik programlama ile çözeceğiz.

Özyinelemeli Formülleştirme

Problemin çözümünü daha küçük alt problemlerin çözümlerinden bulabiliriz. solve(x), x toplamı için gereken minimum para sayısını ifade etsin.

Eğer coins = {1, 3, 4} ise, x toplamına ulaşmak için ilk seçtiğimiz para ya 1, ya 3, ya da 4 olabilir.

• Eğer 1 seçersek, geri kalan x-1 toplamı için solve(x-1) kadar paraya ihtiyacımız olur.
• Eğer 3 seçersek, geri kalan x-3 toplamı için solve(x-3) kadar paraya ihtiyacımız olur.
• Eğer 4 seçersek, geri kalan x-4 toplamı için solve(x-4) kadar paraya ihtiyacımız olur.

Bu durumda özyineleme formülü şu şekilde olur: solve(x) = min(solve(x-1)+1, solve(x-3)+1, solve(x-4)+1) Temel durum solve(0) = 0‘dır.

Memoization

Yukarıdaki özyinelemeli fonksiyon, aynı solve(x) değerini tekrar tekrar hesapladığı için verimsizdir. Memoization tekniği ile, hesaplanan her solve(x) değerini bir dizide saklarız. Fonksiyon tekrar aynı x değeri için çağrıldığında, sonucu yeniden hesaplamak yerine doğrudan diziden alırız.

// value[x], solve(x)'in hesaplanmış değerini tutar
// ready[x], solve(x)'in hesaplanıp hesaplanmadığını belirtir
int value[N];
bool ready[N];

int solve(int x) {
  if (x < 0) return INF;
  if (x == 0) return 0;
  if (ready[x]) return value[x];
  
  int best = INF;
  for (auto c : coins) {
    best = min(best, solve(x - c) + 1);
  }
  
  ready[x] = true;
  value[x] = best;
  return best;
}

Bu algoritmanın zaman karmaşıklığı $O(nk)$ olur (n hedef toplam, k para sayısı).

Döngüsel (Iterative) Yaklaşım

Aynı çözümü özyineleme yerine döngü kullanarak da yazabiliriz. Bu genellikle daha kısa ve biraz daha verimlidir.

value[0] = 0;
for (int x = 1; x <= n; x++) {
  value[x] = INF;
  for (auto c : coins) {
    if (x - c >= 0) {
      value[x] = min(value[x], value[x - c] + 1);
    }
  }
}

Çözüm Sayısını Hesaplamak

Minimum para sayısı yerine, bir toplamı oluşturmanın kaç farklı yolu olduğunu saymak istiyorsak, özyineleme formülündeki min işlemini toplama ile değiştiririz: solve(x) = solve(x-1) + solve(x-3) + solve(x-4) Temel durum solve(0) = 1‘dir (boş küme bir yoldur).

count[0] = 1;
for (int x = 1; x <= n; x++) {
  for (auto c : coins) {
    if (x - c >= 0) {
      count[x] += count[x - c];
      count[x] %= m; // Genellikle sonuç modulo m istenir
    }
  }
}

7.2 En Uzun Artan Altdizi (Longest Increasing Subsequence)

n elemanlı bir dizide, elemanları soldan sağa doğru artan sırada olan en uzun altdiziyi bulma problemidir. Elemanların ardışık olması gerekmez.

length(k), k pozisyonunda biten en uzun artan altdizinin uzunluğunu belirtsin. length(k)‘yı hesaplamak için, array[i] < array[k] koşulunu sağlayan tüm i < k pozisyonları arasındaki en büyük length(i) değerini buluruz ve buna 1 ekleriz.

[Görsel: 6,2,5,1,7,4,8,3 dizisinde en uzun artan altdizinin (2,5,7,8) gösterimi]

for (int k = 0; k < n; k++) {
  length[k] = 1;
  for (int i = 0; i < k; i++) {
    if (array[i] < array[k]) {
      length[k] = max(length[k], length[i] + 1);
    }
  }
}

Bu çözümün zaman karmaşıklığı $O(n^2)$’dir. Bu problem $O(n \log n)$ zamanda da çözülebilir.

7.3 Düzlemde Yollar

n x n bir ızgarada, her hücrede pozitif bir sayı varken, sol üst köşeden sağ alt köşeye sadece sağa ve aşağı hareket ederek gidilebilen ve hücrelerdeki sayıların toplamını maksimize eden yolu bulma problemidir.

[Görsel: 5x5’lik bir düzlemde optimal yolu gösteren şema]

sum(y, x), (y, x) hücresine ulaşan en yüksek puanlı yolun toplamını versin. Özyineleme formülü: sum(y, x) = max(sum(y, x-1), sum(y-1, x)) + value[y][x]

Bu problem, $O(n^2)$’lik bir dinamik programlama çözümü ile çözülebilir.

7.4 Knapsack Problemleri

Knapsack (sırt çantası) problemleri, bir obje kümesinden belirli özelliklere sahip bir alt küme seçmeyi içerir. Klasik bir versiyonu, verilen ağırlıklarla oluşturulabilecek tüm olası toplam ağırlıkları bulmaktır.

Eğer possible(x, k) ilk k ağırlıkla x toplamını oluşturmanın mümkün olup olmadığını belirtirse, özyineleme formülü şu şekildedir: possible(x, k) = possible(x - w_k, k-1) OR possible(x, k-1)

Bu, k. ağırlığı (w_k) ya kullandığımız ya da kullanmadığımız anlamına gelir. Bu da $O(nW)$’lik bir dinamik programlama çözümü ile çözülebilir (W toplam ağırlık).

7.5 Değişiklik Farkı (Edit Distance)

Değişiklik farkı (veya Levenshtein farkı¹), bir kelimeyi diğerine dönüştürmek için gereken minimum karakter ekleme, silme veya değiştirme sayısını verir. Örneğin, “LOVE” ve “MOVIE” arasındaki fark 2’dir (L->M, sonra V’den sonra I ekle).

distance(a, b), x kelimesinin ilk a karakteri ile y kelimesinin ilk b karakteri arasındaki farkı versin. Formül şu şekildedir: distance(a, b) = min(distance(a, b-1)+1, distance(a-1, b)+1, distance(a-1, b-1)+cost) Burada cost, eğer x[a] ve y[b] aynı ise 0, değilse 1’dir. Bu problem $O(nm)$’lik 2 boyutlu bir DP tablosu ile çözülebilir.

6.1 Para Problemi (Coin problem)

Elimizdeki madeni paraları kullanarak n miktarında bir para üstü vermemiz isteniyor. Elimizdeki paraların değerleri coins = {c_1, c_2, ..., c_k}‘dir ve her parayı istediğimiz kadar kullanabiliriz. Amaç, toplam için gereken minimum sayıda madeni para kullanmaktır.

Örneğin, {1, 2, 5, 10, 20, 50, 100, 200} paralarıyla n = 520 oluşturmak için en az 4 para gerekir: 200 + 200 + 100 + 20.

Açgözlü Algoritma

Basit bir açgözlü algoritma, gereken miktar toplanana kadar her zaman seçilebilecek en büyük değerli parayı seçmektir. Bu strateji, standart Euro madeni paraları gibi sistemlerde işe yarar.

Genel Durum

Ancak genel durumda, sahip olduğumuz paralar rastgele değerlerde olabilir ve bu açgözlü algoritma her zaman optimal çözümü vermeyebilir. Örneğin, elimizdeki paralar {1, 3, 4} ise ve istenen toplam 6 ise, açgözlü algoritma 4 + 1 + 1 (3 adet para) çözümünü verirken, en iyi çözüm 3 + 3‘tür (2 adet para).

Para problemi için her zaman çalışan genel bir açgözlü algoritma bilinmemektedir¹.

6.2 Zaman Planlaması (Scheduling)

Çoğu zaman planlama sorusu açgözlü algoritmalar ile çözülebilir. Klasik bir problem, başlangıç ve bitiş zamanları bilinen n tane etkinlikten, birbiriyle çakışmayacak şekilde en fazla sayıda etkinliği seçmektir.

Bu durumda en fazla iki etkinlik seçilebilir, örneğin B ve D.

Farklı açgözlü stratejiler denenebilir:

1. En kısa etkinliği seç: Bu strateji her zaman çalışmaz. Kısa bir etkinlik, daha uzun süren iki etkinliğin seçilmesini engelleyebilir.
2. En erken başlayan etkinliği seç: Bu da her zaman çalışmaz. Erken başlayan uzun bir etkinlik, daha sonraki birçok etkinliği engelleyebilir.
3. En erken biten etkinliği seç: Bu strateji her zaman doğru çalışır. Her adımda, mevcut etkinliklerle çakışmayan ve bitiş zamanı en erken olan etkinliği seçmek, kalan zamanı maksimize ettiği için optimal bir çözüm üretir.

6.3 Görevler ve Son Teslimler (Tasks and Deadlines)

Süresi ve son teslim tarihi bilinen n tane görevimiz olduğunu düşünelim. Amacımız görevleri yapmak için bir sıra oluşturmak. Her görev için $d - x$ puan kazanıyoruz, burada d görevin son teslim tarihi ve x görevi bitirdiğimiz zamandır. En fazla alabileceğimiz toplam puan kaçtır?

İlginç bir şekilde, bu sorunun optimal çözümü son teslim tarihlerine bağlı değildir. Doğru açgözlü strateji, görevleri sürelerine göre artan bir şekilde sıralamaktır. Bunun nedeni, eğer daha uzun süren bir görevi daha kısa süren bir görevden önce yaparsak, bu iki görevin yerini değiştirdiğimizde toplam puanın her zaman artması veya aynı kalmasıdır. Daha kısa görevleri önce bitirmek, sonraki tüm görevlerin bitiş zamanını öne çeker ve toplam puanı iyileştirir.

6.4 Toplamları Küçültmek (Minimizing Sums)

Bize n tane $a_1, a_2, …, a_n$ sayısı verildiğinde, $\sum_{i=1}^{n} \lvert a_i - x\rvert ^c$ toplamını en küçük yapacak x değerini bulma problemi.

c = 1 Durumu

$\sum \lvert a_i - x\rvert $ toplamını minimize etmek için en iyi x değeri, sayıların medyanıdır. Sayılar sıralandıktan sonra ortadaki eleman medyandır.

c = 2 Durumu

$\sum (a_i - x)^2$ toplamını minimize etmek için en iyi x değeri, sayıların aritmetik ortalamasıdır ($(\sum a_i) / n$).

6.5 Veri Sıkıştırma (Data Compression)

Bir metni sıkıştırmak için her karaktere bir bit dizisi (kod) atanabilir. Daha sık geçen karakterlere daha kısa kodlar, daha az geçenlere daha uzun kodlar atayarak metnin toplam uzunluğu azaltılabilir.

Huffman Kodlaması

Huffman Kodlaması, bir metni sıkıştırmak için en optimal kodu (prefix code) üreten bir açgözlü algoritmadır².

Algoritma, karakterlerin metindeki frekanslarına (geçme sıklıklarına) dayalı bir ikili ağaç (binary tree) oluşturur.

1. Her karakteri, frekansı kadar ağırlığa sahip bir düğüm olarak başlat.
2. Her adımda, en düşük ağırlığa sahip iki düğümü seç ve bunları yeni bir ebeveyn düğüm altında birleştir. Yeni düğümün ağırlığı, birleştirilen iki düğümün ağırlıkları toplamıdır.
3. Tek bir kök düğüm kalana kadar bu işleme devam et.

Oluşturulan ağaçta, kökten bir karakterin yaprağına giden yol o karakterin kodunu verir (sola gitmek ‘0’, sağa gitmek ‘1’).

Bu yöntemle, sık geçen ‘A’ karakteri gibi karakterler kısa kodlar alırken, az geçen ‘B’ ve ‘D’ gibi karakterler daha uzun kodlar alır, bu da optimal sıkıştırmayı sağlar.

5.1 Alt küme Oluşturmak (Generating Subsets)

n elemanlı bir kümenin bütün alt kümelerini oluşturmak için iki yaygın yöntem vardır: özyineleme (recursion) veya bit maskeleme (bitmasking).

Yöntem 1: Özyineleme (Recursion)

Bütün alt kümeleri oluşturmanın şık yollarından biri özyinelemedir. Aşağıdaki search fonksiyonu {0, 1, ..., n-1} kümesinin alt kümelerini oluşturur.

vector<int> subset;
void search(int k) {
  if (k == n) {
    // alt kümeyi işle
  } else {
    // k elemanını alt kümeye dahil etme
    search(k + 1);
    // k elemanını alt kümeye dahil et
    subset.push_back(k);
    search(k + 1);
    subset.pop_back();
  }
}

Yöntem 2: Bit Maskeleme (Bitmasking)

n elemanlı bir kümenin her alt kümesi, n bitten oluşan bir tam sayı (bitmask) ile temsil edilebilir. Sayıdaki 1 olan bitler, o pozisyondaki elemanın alt kümede olduğunu gösterir.

for (int b = 0; b < (1 << n); b++) {
  vector<int> subset;
  for (int i = 0; i < n; i++) {
    if (b & (1 << i)) {
      subset.push_back(i);
    }
  }
  // alt kümeyi işle
}

5.2 Permütasyon Oluşturmak (Generating Permutations)

Yöntem 1: Özyineleme (Recursion)

Permütasyonlar da özyineleme kullanılarak oluşturulabilir. Aşağıdaki kod, {0, 1, ..., n-1} kümesinin tüm permütasyonlarını bulur.

vector<int> permutation;
bool chosen[n+1];
void search() {
  if (permutation.size() == n) {
    // permütasyonu işle
  } else {
    for (int i = 0; i < n; i++) {
      if (chosen[i]) continue;
      chosen[i] = true;
      permutation.push_back(i);
      search();
      chosen[i] = false;
      permutation.pop_back();
    }
  }
}

Yöntem 2: C++ next_permutation

C++ standart kütüphanesi, bir dizinin bir sonraki leksikografik permütasyonunu oluşturan next_permutation fonksiyonunu içerir.

vector<int> p;
for (int i = 0; i < n; i++) {
  p.push_back(i);
}
do {
  // permütasyonu işle
} while (next_permutation(p.begin(), p.end()));

5.3 Geri İzleme (Backtracking)

Geri izleme, boş bir çözümle başlayıp çözümü adım adım büyüten bir tam arama tekniğidir. Arama, çözüme ulaşmayan yolları terk ederek (geri izleyerek) ilerler.

Klasik bir örnek n-Vezir Problemi‘dir: n x n bir satranç tahtasına n veziri, birbirlerini tehdit etmeyecek şekilde yerleştirmek.

Bu problem, her satıra sırayla bir vezir koyarak ve her yeni vezirin öncekileri tehdit etmediğinden emin olarak geri izleme ile çözülebilir.

5.4 Aramayı Budama (Pruning The Search)

Arama ağacını budayarak geri izleme optimize edilebilir. Buradaki fikir, yarı-çözümün tam bir çözüme ulaşamayacağı anlaşıldığı anda o arama dalını terk etmektir. Bu optimizasyonlar, aramanın verimliliğini ciddi derecede artırabilir.

Örneğin, n x n bir tahtada sol üst köşeden sağ alt köşeye her kareden tam bir kez geçerek yol bulma probleminde, aşağıdaki gibi optimizasyonlar yapılabilir:

1. Simetri: Sadece aşağı veya sağa giderek başlayıp sonucu ikiyle çarpmak.
2. Erken Varış: Tüm kareler gezilmeden hedefe varıldıysa yolu geçersiz saymak.
3. Bölünme: Yol bir duvara ulaştığında, eğer sola ve sağa gidebiliyorsa tahtayı ikiye böler ve tüm kareleri gezmek imkansız hale gelir. Bu durumda arama dalı budanır.

Bu tür küçük optimizasyonlar, arama süresini yüzlerce kat hızlandırabilir.

5.5 Ortada Buluşmak (Meet in the middle)

Ortada buluşmak (meet-in-the-middle), arama uzayını iki eşit parçaya bölerek çalışan bir tekniktir¹. Her parça için ayrı bir arama yapılır ve sonda bu aramaların sonuçları birleştirilir. Genelde, $O(2^n)$ olan bir zaman karmaşıklığını $O(2^{n/2})$’ye indirebilir.

Örnek problem: n elemanlı bir kümede, toplamları x olan bir alt küme bulmak.

1. Kümeyi n/2 elemanlı A ve B olmak üzere ikiye ayır.
2. A kümesinin tüm alt küme toplamlarını hesapla ve bir S_A listesine kaydet.
3. B kümesinin tüm alt küme toplamlarını hesapla ve bir S_B listesine kaydet.
4. S_A‘dan her s_a toplamı için, S_B‘de x - s_a değerinin olup olmadığını kontrol et.

Bu yaklaşım, $O(2^n)$ yerine $O(2^{n/2})$ zamanda çalışır çünkü her iki yarım için de arama uzayı önemli ölçüde küçülür.

Bu bölümde C++ standart kütüphanesindeki en önemli veri yapıları tanıtılacaktır. Standart kütüphane zamandan tasarruf sağlayacağı için mümkün olduğunca onu kullanmaya özen gösterilmelidir.

4.1 Dinamik Diziler

Dinamik dizi, programın çalışması sırasında boyutu değiştirilebilen bir dizidir. C++’daki en popüler dinamik dizi vector yapısıdır.

Aşağıdaki kod, boş bir vektör oluşturur ve bu vektöre üç eleman ekler:

vector<int> v;
v.push_back(3); // [3]
v.push_back(2); // [3,2]
v.push_back(5); // [3,2,5]

Elemanlara sıradan bir dizideki gibi erişilebilir:

cout << v[0] << "\n"; // 3

size() fonksiyonu vektördeki eleman sayısını döndürür. Vektördeki elemanları yazdırmak için:

for (int i = 0; i < v.size(); i++) {
  cout << v[i] << "\n";
}
// Veya daha kısa bir yol:
for (auto x : v) {
  cout << x << "\n";
}

back() fonksiyonu son elemanı döndürürken, pop_back() son elemanı siler.

Vektörler başlangıç değerleriyle de oluşturulabilir:

// 5 elemanlı bir vektör
vector<int> v1 = {2, 4, 2, 5, 1};

// 10 elemanlı ve tüm değerleri 0 olan bir vektör
vector<int> v2(10);

// 10 elemanlı ve tüm değerleri 5 olan bir vektör
vector<int> v3(10, 5);

push_back operasyonunun ortalama zaman karmaşıklığı O(1)‘dir¹.

string veri yapısı da vector gibi kullanılabilen bir dinamik dizidir ve ek olarak + ile birleştirme, substr ile alt string alma gibi özelliklere sahiptir.

4.2 Küme (Set) Yapıları

Küme, elemanlar topluluğu barındıran bir veri yapısıdır. Eleman ekleme, arama ve silme işlemlerini destekler.

• set: Dengeli bir ikili ağaç (balanced binary tree) üzerine kuruludur ve işlemleri $O(\log n)$ sürede çalışır. Elemanları sıralı tutar.
• unordered_set: Kıyım (hashing) kullanır ve işlemleri ortalama olarak $O(1)$ sürede çalışır. Elemanlar sırasızdır.

set<int> s;
s.insert(3);
s.insert(2);
s.insert(5);
cout << s.count(3) << "\n"; // 1 (var)
cout << s.count(4) << "\n"; // 0 (yok)
s.erase(3);
cout << s.count(3) << "\n"; // 0

Kümelerin önemli bir özelliği, bütün elemanlarının farklı olmasıdır. Bir eleman birden fazla kez eklenemez.

multiset ve unordered_multiset ise bir elemanın birden fazla kopyasını barındırabilen küme türleridir.

erase fonksiyonu bir multiset‘ten bir elemanın tüm kopyalarını siler. Sadece bir kopyayı silmek için s.erase(s.find(5)); gibi bir kullanım gerekir.

4.3 Map Yapıları

Bir map, anahtar-değer çiftlerinden (key-value pairs) oluşan genelleştirilmiş bir dizidir.

• map: Dengeli ikili ağaç yapısındadır, anahtarları sıralı tutar ve erişim $O(\log n)$’dir.
• unordered_map: Hashleme kullanır, anahtarlar sırasızdır ve erişim ortalama $O(1)$’dir.

map<string, int> m;
m["monkey"] = 4;
m["banana"] = 3;
cout << m["banana"] << "\n"; // 3

Eğer istenen anahtar map’te bulunmuyorsa, otomatik olarak varsayılan bir değerle (sayılar için 0) eklenir. count fonksiyonu bir anahtarın map’te olup olmadığını kontrol etmek için kullanılabilir.

4.4 İteratörler ve Aralıklar (Iterators and Ranges)

İteratör, bir veri yapısındaki bir elemanı gösteren bir değişkendir. begin() iteratörü ilk elemanı, end() iteratörü ise son elemandan sonraki pozisyonu gösterir.

Bu iteratörler sort, reverse, random_shuffle gibi birçok standart kütüphane fonksiyonunda kullanılır:

sort(v.begin(), v.end());

set gibi veri yapılarının elemanlarına erişmek için iteratörler kullanılır:

set<int> s = {2, 5, 6, 8};
auto it = s.begin();
cout << *it << "\n"; // 2 (en küçük eleman)

it = s.end();
it--;
cout << *it << "\n"; // 8 (en büyük eleman)

set için find(x), lower_bound(x) ve upper_bound(x) gibi fonksiyonlar da iteratör döndürür.

4.5 Diğer Yapılar

• bitset: Her değeri 0 ya da 1 olan sabit boyutlu bir dizidir. Hafıza açısından verimlidir ve bit operasyonları (&, |, ^) ile hızlıca manipüle edilebilir.

    bitset<10> s;
    s[1] = 1;
    s[3] = 1;
    cout << s.count() << "\n"; // 1 olan bit sayısı
  

• deque: Hem başından hem de sonundan eleman eklenip çıkarılabilen (push_front, pop_front, push_back, pop_back) dinamik bir dizidir. Ortalama O(1) zamanda çalışır.
• stack: Sadece en üstten eleman eklenen (push) ve çıkarılan (pop) bir “LIFO” (Last-In, First-Out) yapısıdır.
• queue: Sonuna eleman eklenen (push) ve başından eleman çıkarılan (pop) bir “FIFO” (First-In, First-Out) yapısıdır.
• priority_queue: Her zaman en büyük (veya en küçük) elemana hızlı erişim sağlayan bir yapıdır. Eleman ekleme ve çıkarma $O(\log n)$ sürer.

    priority_queue<int> q;
    q.push(3);
    q.push(5);
    q.push(2);
    cout << q.top() << "\n"; // 5
    q.pop();
    cout << q.top() << "\n"; // 3
  

4.6 Sıralama ile Karşılaştırma

Bir problemi hem sıralama hem de veri yapıları ile çözmek mümkün olabilir. Zaman karmaşıklıkları aynı olsa bile (O(n log n) gibi), pratik performansları farklılık gösterebilir. Örneğin, iki listedeki ortak eleman sayısını bulma probleminde, sıralama tabanlı bir çözüm genellikle set veya map tabanlı bir çözümden daha hızlı çalışır çünkü sıralama basit bir işlemdir ve sadece bir kez yapılırken, set gibi yapılar her işlemde daha karmaşık bir ağaç yapısını yönetir.

Verimli çalışan sıralama algoritmaları $O(n \log n)$ zamanda çalışır ve genelde içeriğinde sıralama bulunan algoritmalar da bu zaman karmaşıklığına sahiptir.

3.1 Sıralama Teorisi

Temel sıralama problemi şöyledir: n elemana sahip bir diziyi artan sırada sıralayın. Örneğin [1, 3, 8, 2, 9, 2, 5, 6] dizisi sıralandıktan sonra [1, 2, 2, 3, 5, 6, 8, 9] haline dönüşür.

$O(n^2)$ Algoritmalar

Basit dizi sıralama algoritmaları $O(n^2)$ zamanda çalışır. Bu algoritmalar kısa olup genelde iki for döngüsüyle çalışır. Çok bilinen $O(n^2)$ algoritmalarından biri olan kabarcık sıralaması (bubble sort), dizideki elemanların değerlerine göre “kabarcık” gibi yer değiştirmesiyle çalışır.

Kabarcık sıralaması n defa tur atar. Her turda, algoritma sıraya uymayan iki ardışık eleman bulduğunda yerlerini değiştirir.

for (int i = 0; i < n; i++) {
  for (int j = 0; j < n - 1; j++) {
    if (array[j] > array[j+1]) {
      swap(array[j], array[j+1]);
    }
  }
}

Ters Elemanlar (Inversions)

Bir dizide a < b iken array[a] > array[b] olması durumuna ters eleman (inversion) denir. Dizide herhangi bir ters eleman durumu kalmayınca dizi sıralanmış olur. En kötü durumda (dizi tersten sıralıysa) ters eleman sayısı $\frac{n(n-1)}{2} = O(n^2)$ olur. Sadece ardışık elemanları değiştiren algoritmalar her adımda en fazla bir ters eleman durumunu düzeltebildiği için zaman karmaşıklıkları en az $O(n^2)$’dir.

$O(n \log n)$ Algoritmalar

Bir diziyi, sadece ardışık eleman değiştirmeye bağlı kalmayarak $O(n \log n)$’lık algoritmalarla sıralayabiliriz. Bu tip algoritmalardan biri özyinelemeye (recursion) dayalı birleştirme sıralamasıdır (merge sort)¹.

Birleştirme sıralaması array[a...b] alt dizisini aşağıdaki gibi sıralar:

1. Eğer a == b ise, alt dizi zaten sıralıdır.
2. Orta elemanın pozisyonunu hesapla: $k = \lfloor(a+b)/2\rfloor$.
3. Özyinelemeli bir şekilde array[a...k] alt dizisini sırala.
4. Özyinelemeli bir şekilde array[k+1...b] alt dizisini sırala.
5. Sıralı alt dizileri birleştirerek array[a...b]‘yi oluştur.

Sıralama Alt Sınırı (Lower Bound)

Elemanları sadece birbiriyle karşılaştırarak çalışan sıralama algoritmaları için zaman karmaşıklığı alt sınırı $O(n \log n)$’dir. Bunun nedeni, n elemanın n! tane olası permütasyonu olması ve her karşılaştırmanın bu olasılıkları en fazla yarıya indirmesidir. Bu durumu ayırt etmek için en az $\log_2(n!) \approx O(n \log n)$ karşılaştırma gerekir.

Sayarak Sıralama (Counting Sort)

Eğer dizideki her elemanın değerinin $0…c$ arasında olduğu biliniyorsa ve $c=O(n)$ ise, sayarak sıralama (counting sort) ile diziyi $O(n)$ zamanda sıralayabiliriz. Bu algoritma, her elemanın dizide kaç kez geçtiğini sayan bir frekans dizisi oluşturur ve bu diziyi kullanarak sıralı diziyi oluşturur.

3.2 C++ Dilinde Sıralama

Yarışmalarda kendi sıralama algoritmanızı yazmak yerine standart kütüphanelerdeki hazır fonksiyonları kullanmak daha pratiktir. C++’daki sort fonksiyonu verimli bir şekilde çalışır.

Vector sıralama:

vector<int> v = {4, 2, 5, 3, 5, 8, 3};
sort(v.begin(), v.end()); // v becomes {2, 3, 3, 4, 5, 5, 8}

Dizi (array) sıralama:

int a[] = {4, 2, 5, 3, 5, 8, 3};
int n = 7;
sort(a, a + n);

String sıralama:

string s = "monkey";
sort(s.begin(), s.end()); // s becomes "ekmnoy"

Karşılaştırma İşlemleri

sort fonksiyonu, pair ve tuple gibi yapıları da sıralayabilir. Sıralama önce ilk elemana göre, eşitlik durumunda ikinci elemana göre vb. yapılır.

Kendi tanımladığınız yapılar (struct) için operator< fonksiyonunu tanımlamanız gerekir:

struct P {
  int x, y;
  bool operator<(const P &p) {
    if (x != p.x) return x < p.x;
    else return y < p.y;
  }
};

Alternatif olarak sort fonksiyonuna üçüncü bir argüman olarak bir karşılaştırma fonksiyonu da verebilirsiniz.

3.3 İkili Arama Algoritması (Binary Search)

Eğer bir dizi sıralıysa, içinde bir elemanı aramak için O(n)‘lik lineer arama yerine O(log n)‘de çalışan ikili arama (binary search) kullanılabilir. İkili arama, arama aralığını her adımda ikiye bölerek çalışır.

Yöntem 1: Aralık Küçültme

int a = 0, b = n - 1;
while (a <= b) {
  int k = (a + b) / 2;
  if (array[k] == x) {
    // bulundu
  }
  if (array[k] > x) b = k - 1;
  else a = k + 1;
}

Yöntem 2: Zıplamalı Arama

int k = 0;
for (int b = n / 2; b >= 1; b /= 2) {
  while (k + b < n && array[k + b] <= x) {
    k += b;
  }
}
if (array[k] == x) {
  // bulundu
}

C++ Fonksiyonları

C++ standart kütüphanesi, sıralı diziler üzerinde logaritmik zamanda çalışan hazır ikili arama fonksiyonları sunar:

• lower_bound: Değeri en az x olan ilk elemanın işaretçisini (pointer/iterator) döner.
• upper_bound: Değeri x‘ten büyük olan ilk elemanın işaretçisini döner.
• equal_range: Yukarıdaki iki işaretçiyi bir çift olarak döner.

Bu fonksiyonları kullanarak bir elemanın dizide olup olmadığını kontrol edebilir veya kaç adet bulunduğunu sayabilirsiniz.

En Küçük Çözümü Bulmak

İkili arama, belirli bir k değerinden sonra true olan bir ok(x) fonksiyonu için bu en küçük k değerini bulmak amacıyla da kullanılabilir. Bu, “cevaba ikili arama” (binary search on the answer) olarak bilinen yaygın bir tekniktir.

Zaman karmaşıklığı, bir algoritmanın bir girdi için tahmini olarak ne kadar süre gerektireceğini belirtir. Bunun amacı, girdinin boyutuna göre değişen ve algoritmanın verimliliğini gösteren bir fonksiyon oluşturmaktır. Zaman karmaşıklığını hesaplayarak, algoritmayı koda dökmeden önce yeterince hızlı olup olmadığını anlayabiliriz.

2.1 Hesaplama Kuralları

Bir algoritmanın zaman karmaşıklığı O(...) ile gösterilir. Genelde, girdi büyüklüğü olarak n değişkeni kullanılır. Örneğin sayılardan oluşan bir dizide n dizinin büyüklüğünü, eğer girdi bir yazı ise n yazının uzunluğunu verir.

Döngüler

Algoritmanın yavaşlamasına neden olan genel sebeplerden biri, girdi üzerinde çalışan çok fazla döngü bulundurmasıdır. Bir algoritma ne kadar çok iç içe geçmiş döngü içerirse o kadar yavaşlar. Eğer k tane iç içe geçmiş döngü varsa zaman karmaşıklığı O(n^k) olur.

Örneğin aşağıdaki kodun zaman karmaşıklığı O(n)‘dir:

for (int i = 1; i <= n; i++) {
  // kod
}

Ve aşağıdaki kodun zaman karmaşıklığı ise O(n^2)‘dir:

for (int i = 1; i <= n; i++) {
  for (int j = 1; j <= n; j++) {
    // kod
  }
}

Büyüklük Sırası (Order of Magnitude)

Zaman karmaşıklığı bize döngü içindeki kodun tam olarak kaç defa çalışacağını vermez. Örneğin aşağıdaki kodların hepsinin zaman karmaşıklığı O(n)‘dir, ancak döngü sayıları farklıdır.

for (int i = 1; i <= 3*n; i++) {
  // kod
}

for (int i = 1; i <= n+5; i++) {
  // kod
}

for (int i = 1; i <= n; i += 2) {
  // kod
}

Aşamalar (Phases)

Eğer algoritma birden çok aşamadan oluşuyorsa, toplam zaman karmaşıklığı en yavaş aşamanın karmaşıklığına eşittir. Çünkü genelde en yavaş çalışan aşama, toplam süreyi domine eder.

Çoklu Değişkenler

Bazen zaman karmaşıklığı birden çok faktöre bağlıdır. Bu durumda formül birden çok değişken içerir. Örneğin aşağıdaki kodun zaman karmaşıklığı O(nm)‘dir:

for (int i = 1; i < n; i++) {
  for (int j = 1; j <= m; j++) {
    // kod
  }
}

Özyineleme (Recursion)

Özyinelemeli bir fonksiyonun zaman karmaşıklığı, fonksiyonun kaç kez çağrıldığı ile bir çağrının zaman karmaşıklığının çarpımına eşittir.

Örneğin, aşağıdaki f(n) fonksiyonu n kez çağrılır ve her çağrı O(1) sürdüğü için toplam karmaşıklık O(n)‘dir.

void f(int n) {
  if (n == 1) return;
  f(n-1);
}

Aşağıdaki g(n) fonksiyonunda ise her çağrı iki yeni çağrı oluşturur. Bu da toplamda 1 + 2 + 4 + ... + 2^(n-1) = 2^n - 1 çağrıya yol açar. Dolayısıyla zaman karmaşıklığı O(2^n)‘dir.

void g(int n) {
  if (n == 1) return;
  g(n-1);
  g(n-1);
}

2.2 Karmaşıklık Sınıfları (Complexity Classes)

Zaman karmaşıklığı en fazla O(n^k) (k sabit) olan bir algoritma polinomdur. O(2^n) ve O(n!) dışındaki yukarıdaki karmaşıklıklar polinomdur.

2.3 Verimliliği Tahmin Etme

Girdinin büyüklüğüne göre, 1 saniyelik zaman limitinde beklenen zaman karmaşıklığı aşağıdaki gibidir:

2.4 En Büyük Alt Dizi Toplamı

Problem: n elemanlı bir dizide, elemanları ardışık olan ve toplamı en büyük olan alt dizinin toplamını bulmak.

Örneğin, [-1, 2, 4, -3, 5, 2, -5, 2] dizisi için en büyük alt dizi toplamı [2, 4, -3, 5, 2] alt dizisinden gelen 10’dur.

1. Algoritma: $O(n^3)$

Tüm olası alt dizileri üç iç içe döngü ile deneyen kaba kuvvet çözümü.

int best = 0;
for (int a = 0; a < n; a++) {
  for (int b = a; b < n; b++) {
    int sum = 0;
    for (int k = a; k <= b; k++) {
      sum += array[k];
    }
    best = max(best, sum);
  }
}
cout << best << "\n";

2. Algoritma: $O(n^2)$

İçteki döngülerden birini kaldırarak iyileştirilmiş çözüm.

int best = 0;
for (int a = 0; a < n; a++) {
  int sum = 0;
  for (int b = a; b < n; b++) {
    sum += array[b];
    best = max(best, sum);
  }
}
cout << best << "\n";

3. Algoritma: $O(n)$ (Kadane’in Algoritması)

Her pozisyonda biten en büyük alt dizi toplamını bularak ilerleyen verimli çözüm.

int best = 0, sum = 0;
for (int k = 0; k < n; k++) {
  sum = max(array[k], sum + array[k]);
  best = max(best, sum);
}
cout << best << "\n";

Bu, problem için mümkün olan en iyi zaman karmaşıklığıdır.