``
Bir optimizasyon problemi, belirli kısıtlar altında bir amaç fonksiyonunu en küçük veya en büyük yapmayı hedefler. Açgözlü algoritma ise çözümü adım adım kurar ve her aşamada yerel olarak en iyi görünen kararı verir.
Bir çözüm $S$ ve seçilebilecek adaylar kümesi $C$ olsun. Algoritma her adımda yaklaşık olarak şu seçimi yapar:
\[x^* = \arg\max_{x \in C} kazanç(x)\]Ancak yerel maksimumun küresel maksimuma eşit olması garanti değildir. Açgözlü yöntemin optimal olması için problemde genellikle iki önemli özellik aranır:
| Özellik | Sorduğumuz soru | Anlamı |
|---|---|---|
| Açgözlü seçim | İlk yerel seçim güvenli mi? | Bu seçim optimal çözüme dönüştürülebilir. |
| Optimal alt yapı | Kalan problem bağımsız mı? | Kalan kısmın optimal çözümü kullanılabilir. |
| Geri dönmeme | Karar değiştirilecek mi? | Açgözlü algoritma seçimini kalıcı yapar. |
En yaygın yöntemlerden biri değiş tokuş argümanıdır. Önce herhangi bir optimal çözüm düşünülür. Eğer bu çözüm açgözlü seçimi içermiyorsa, çözümdeki başka bir seçim açgözlü seçimle değiştirilir. Değişiklik çözümün geçerliliğini ve değerini bozmuyorsa, açgözlü seçimi içeren bir optimal çözüm bulunduğu kanıtlanır.
İkinci adımda problem küçültülür. İlk güvenli seçim yapıldıktan sonra kalan bölümün aynı yapıda bir alt problem olduğu gösterilir. Böylece tümevarım kullanılarak algoritmanın tamamının optimal olduğu sonucuna ulaşılır.
Her aktivitenin başlangıç zamanı $s_i$ ve bitiş zamanı $f_i$ olsun. Amaç, zamanları çakışmayan en fazla sayıda aktiviteyi seçmektir. Doğru açgözlü kural şudur: En erken biten uygun aktiviteyi seç.
Neden en kısa süreni veya en erken başlayanı seçmiyoruz?
| Strateji | Optimal mi? | Sorun |
|---|---|---|
| En erken biteni seç | Evet | Gelecek aktiviteler için en fazla alanı bırakır. |
| En erken başlayanı seç | Hayır | Çok geç biten bir aktivite seçilebilir. |
| En kısa süreliyi seç | Hayır | Konumu kötü olduğu için iki aktiviteyi engelleyebilir. |
Örneğin aktiviteler $(1,4)$, $(3,5)$, $(0,6)$, $(5,7)$ ve $(8,9)$ ise önce $(1,4)$ seçilir. Ardından başlangıcı 4 veya daha büyük olanlar arasından $(5,7)$, sonra $(8,9)$ alınır. Sonuç üç aktivitedir.
def aktivite_sec(aktiviteler):
# Aktiviteleri bitiş zamanına göre sıralar.
aktiviteler.sort(key=lambda aktivite: aktivite[1])
secilenler = []
son_bitis = float("-inf")
for baslangic, bitis in aktiviteler:
# Önceki aktivite bittiyse bu seçim güvenlidir.
if baslangic >= son_bitis:
secilenler.append((baslangic, bitis))
son_bitis = bitis
return secilenler
Sıralama $O(n \log n)$, tarama ise $O(n)$ sürdüğünden toplam karmaşıklık $O(n \log n)$ olur. Veriler zaten bitiş zamanına göre sıralıysa süre $O(n)$ seviyesine iner.
Para üstü probleminde standart madeni paralarla en büyük değeri seçmek işe yarayabilir. Fakat para değerleri ${1,3,4}$ ve hedef $6$ olduğunda açgözlü yöntem $4+1+1$ ile üç para kullanır; optimal çözüm $3+3$ ile iki paradır. Demek ki hızlı ve sezgisel görünmek kanıt yerine geçmez.
Kısacası bir açgözlü algoritmaya güvenmeden önce güvenli seçimi tanımlayın, değiş tokuş argümanını kurun ve kalan problemin optimal alt yapıya sahip olduğunu gösterin. Bu üçlü sağlanıyorsa açgözlü yaklaşım yalnızca hızlı değil, matematiksel olarak da iştah açıcıdır.
]]>Bir alt dizi (subsequence) oluştururken eleman silebiliriz ancak kalan elemanların sırasını değiştiremeyiz. Elemanların yan yana bulunması gerekmez. Buna karşılık alt metin veya alt dizi parçası (substring/subarray) kesintisiz olmalıdır.
| Kavram | Elemanlar bitişik mi? | Sıra korunur mu? | Örnek |
|---|---|---|---|
| Alt dizi | Hayır | Evet | ABCDEF → ACE |
| Alt metin | Evet | Evet | ABCDEF → BCD |
| Alt küme | Hayır | Hayır | {A,B,C} → {C,A} |
Bu ayrım önemlidir; yanlış kavramı seçmek, çalışan ama bambaşka bir problemi çözen algoritmalar yazmamıza yol açar.
LIS, sayılar arasından sırası korunacak biçimde seçilebilen en uzun artan diziyi arar. Örneğin [3, 1, 5, 2, 6, 4, 9] için [1, 2, 4, 9] geçerli bir sonuçtur.
Klasik dinamik programlama yaklaşımında $dp[i]$, i konumunda biten en uzun artan alt dizinin uzunluğudur:
Uygun bir $j$ yoksa $dp[i]=1$ olur. İki iç içe döngü nedeniyle zaman karmaşıklığı $O(n^2)$, bellek karmaşıklığı ise $O(n)$ seviyesindedir.
def lis_length(numbers):
# dp[i], i. elemanda biten en uzun artan alt diziyi tutar.
dp = [1] * len(numbers)
for i in range(len(numbers)):
for j in range(i):
if numbers[j] < numbers[i]:
dp[i] = max(dp[i], dp[j] + 1)
return max(dp, default=0)
Daha büyük girdilerde ikili arama kullanan “sabır sıralaması” yaklaşımı süreyi $O(n\log n)$ düzeyine indirir. Ancak bu yöntemde tutulan yardımcı dizi, her zaman LIS’in kendisi değildir; öncelikle mümkün olan en küçük kuyruk değerlerini temsil eder.
LCS, iki dizide veya metinde sırayı bozmadan ortak kalan en uzun yapıyı bulur. KODLAMA ve KAPLAMA sözcükleri karşılaştırıldığında ortak karakterlerin sırası, benzerliğin iskeletini oluşturur.
$dp[i][j]$, ilk metnin ilk $i$, ikinci metnin ilk $j$ karakteri için LCS uzunluğu olsun:
\[dp[i][j] = \begin{cases}dp[i-1][j-1]+1, & x_i=y_j \\ \max(dp[i-1][j],dp[i][j-1]), & x_i\ne y_j\end{cases}\]def lcs_length(first, second):
# Tablo, metin önekleri arasındaki en iyi ortak uzunlukları saklar.
dp = [[0] * (len(second) + 1) for _ in range(len(first) + 1)]
for i, left in enumerate(first, 1):
for j, right in enumerate(second, 1):
if left == right:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
return dp[-1][-1]
Bu çözümün zaman ve bellek maliyeti $O(nm)$’dir. Yalnızca uzunluk gerekiyorsa iki satır tutularak bellek $O(\min(n,m))$ seviyesine düşürülebilir.
Ham LCS değeri uzun metinleri doğal olarak avantajlı kılar. Bu nedenle normalize edilmiş bir skor kullanabiliriz:
\[S(A,B)=\frac{2\cdot LCS(A,B)}{|A|+|B|}\]Skor $0$ ile $1$ arasındadır; $1$, dizilerin tamamen aynı olduğunu gösterir.
| Yöntem | Sıraya duyarlı mı? | Güçlü olduğu alan |
|---|---|---|
| LCS benzerliği | Evet | Sürüm ve değişiklik analizi |
| Jaccard | Genellikle hayır | Kelime veya etiket kümeleri |
| Levenshtein | Evet | Yazım hataları ve düzenleme maliyeti |
| Kosinüs benzerliği | Hayır | Büyük belgelerde konu benzerliği |
Gerçek metinlerde karşılaştırmadan önce küçük harfe dönüştürme, noktalama temizleme ve kelimelere ayırma yapılabilir. Karakter tabanlı LCS küçük yazım değişikliklerini, kelime tabanlı LCS ise cümle yapısını daha iyi yakalar. Kısacası LIS yükselişleri, LCS ortak düzeni bulur; benzerlik skoru da bu düzeni yorumlanabilir bir sayıya dönüştürür.
]]>``
$n$ elemanlı bir dizide a[i] değerini değiştiren nokta güncellemeleri ve $[l,r]$ aralığının toplamını isteyen sorgular bulunsun. Doğrudan yaklaşımda güncelleme $O(1)$, sorgu ise $O(n)$ sürer. Prefix toplam dizisi kullanırsak sorguyu $O(1)$ yapabiliriz; fakat tek bir değişiklikten sonra birçok prefix değeri yenileneceği için güncelleme $O(n)$ olur.
İdeal hedef, iki işlemi de yaklaşık $O(\log n)$ zamanda gerçekleştirmektir. Dengeli ağaç mantığı burada devreye girer: Dizinin tamamını değil, değişiklikten etkilenen az sayıdaki özet bilgiyi güncelleriz.
| Yaklaşım | Aralık toplamı | Nokta güncelleme | Bellek |
|---|---|---|---|
| Doğrudan dizi | $O(n)$ | $O(1)$ | $O(n)$ |
| Prefix toplam | $O(1)$ | $O(n)$ | $O(n)$ |
| Fenwick ağacı | $O(\log n)$ | $O(\log n)$ | $O(n)$ |
| Segment ağacı | $O(\log n)$ | $O(\log n)$ | $O(n)$ |
Binary Indexed Tree olarak da bilinen Fenwick ağacı, her hücrede belirli uzunluktaki bir aralığın toplamını saklar. Bir indeksin kapsadığı bölüm, en düşük anlamlı bitiyle belirlenir:
\[\operatorname{lowbit}(x)=x\mathbin{\&}(-x)\]Örneğin 12 sayısının ikilik gösterimi 1100 olduğundan lowbit(12)=4 olur. Güncelleme sırasında i += lowbit(i), prefix sorgusunda ise i -= lowbit(i) adımları izlenir.
class Fenwick {
int n;
vector<long long> bit;
public:
Fenwick(int n) : n(n), bit(n + 1, 0) {}
void add(int i, long long delta) {
for (; i <= n; i += i & -i)
bit[i] += delta;
}
long long prefixSum(int i) {
long long result = 0;
for (; i > 0; i -= i & -i)
result += bit[i];
return result;
}
long long rangeSum(int l, int r) {
return prefixSum(r) - prefixSum(l - 1);
}
};
Kod 1 tabanlı indeksleme kullanır. [l,r] toplamı, iki prefix toplamının farkıdır:
Bir değeri yeniDeger yapmak için önce delta = yeniDeger - eskiDeger hesaplanıp add(i, delta) çağrılmalıdır.
Segment ağacı, kökünde tüm diziyi; çocuklarında ise aralığın sol ve sağ yarılarını saklar. Yapraklar tek elemanları temsil eder. Bir düğümün değeri, toplama probleminde çocuklarının toplamıdır:
\[tree[v]=tree[2v]+tree[2v+1]\]long long query(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[v];
int tm = (tl + tr) / 2;
return query(v * 2, tl, tm, l, min(r, tm))
+ query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void update(int v, int tl, int tr, int pos, long long value) {
if (tl == tr) tree[v] = value;
else {
int tm = (tl + tr) / 2;
if (pos <= tm) update(v * 2, tl, tm, pos, value);
else update(v * 2 + 1, tm + 1, tr, pos, value);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
}
Sorgu yalnızca hedef aralıkla kesişen düğümlere iner. Güncelleme de yapraktan köke kadar tek bir yol izler; ağacın yüksekliği $\log_2 n$ civarındadır.
Yalnızca toplam, XOR veya benzeri prefix farkıyla çözülebilen işlemler varsa Fenwick ağacı kısa, hızlı ve az bellek tüketen seçenektir. Minimum, maksimum, maksimum alt dizi toplamı ya da ileride lazy propagation ile aralık güncellemesi gerekiyorsa segment ağacı daha uygundur.
Kısacası Fenwick ağacı çevik bir motosiklet, segment ağacı ise donanımlı bir arazi aracıdır. Yol düzse motosiklet harikadır; sorgular çamurlanmaya başladığında arazi aracı gülümseyerek öne çıkar.
]]>Yalnızca $1$ ve kendisine tam bölünebilen, $1$’den büyük doğal sayılara asal sayı denir. Örneğin $2, 3, 5, 7$ asaldır; $12$ ise $2 \times 2 \times 3$ biçiminde ayrılabildiği için bileşiktir.
Aritmetiğin Temel Teoremi’ne göre $1$’den büyük her tam sayı, asal sayıların çarpımı olarak tek bir biçimde yazılabilir. Çarpanların sırası sonucu değiştirmez:
\[360 = 2^3 \times 3^2 \times 5\]Bu özellik, asal sayıları doğal sayıların yapı taşları hâline getirir. Bir sayının asal olup olmadığını kontrol etmek için $2$’den başlayıp sayının kendisine kadar ilerlemek gereksizdir. Eğer $n$ bileşikse çarpanlarından en az biri $\sqrt{n}$ değerinden küçük veya ona eşittir. Dolayısıyla kontrol sınırı $\sqrt{n}$ olabilir.
from math import isqrt
def asal_mi(n):
if n < 2:
return False
for bolen in range(2, isqrt(n) + 1):
if n % bolen == 0:
return False
return True
Bu fonksiyonun zaman karmaşıklığı yaklaşık $O(\sqrt{n})$ olur. Belirli bir sınıra kadarki bütün asalları bulmak gerektiğinde ise Eratosthenes Eleği daha uygundur.
Modüler aritmetik, bölme işleminden kalanlarla ilgilenir. Saat 10’a üç saat ekleyince 13 değil, 1 denmesi bunun günlük hayattaki örneğidir. Matematiksel olarak:
\[13 \equiv 1 \pmod{12}\]Bu ifade, $13$ ve $1$ sayılarının 12 ile bölündüğünde aynı kalanı verdiğini söyler. Modüler işlemler büyük değerleri kontrol altında tutar:
\[10^{100} \bmod 9 = 1\]Çünkü $10 \equiv 1 \pmod 9$ olduğundan $10^{100} \equiv 1^{100} \equiv 1 \pmod 9$ elde edilir.
| Normal işlem | Modüler karşılığı | Avantajı |
|---|---|---|
| $a+b$ | $(a \bmod m+b \bmod m)\bmod m$ | Sayıları küçük tutar |
| $a\times b$ | $((a\bmod m)(b\bmod m))\bmod m$ | Dev çarpımları sınırlar |
| $a^b$ | $a^b\bmod m$ | Kriptografide kullanılır |
| $a-b$ | $(a-b+m)\bmod m$ | Negatif kalanı önler |
Programlama dillerinin negatif sayılarda kalan davranışı farklı olabileceği için güvenli normalleştirme genellikle ((x % m) + m) % m biçimindedir.
Python tam sayıları ihtiyaç oldukça büyüyebilir. C, C++ ve Java gibi dillerdeyse sabit genişlikli türler taşabilir. Örneğin işaretli 64 bit bir tam sayının üst sınırı $2^{63}-1$ değeridir.
| Yaklaşım | Kullanım alanı | Dezavantajı |
|---|---|---|
| 64 bit tam sayı | Hızlı genel hesaplama | Taşma riski |
| BigInteger | Kesin ve dev değerler | Daha yavaş çalışma |
| Modüler hesaplama | Yalnızca kalan gerekiyorsa | Asıl sayı korunmaz |
Sonuç yalnızca belirli bir modüle göre isteniyorsa dev sayıyı üretmek yerine her adımda mod almak en verimli çözümdür.
$a^b$ değerini $b$ kez çarpmak $O(b)$ işlem gerektirir. Binary exponentiation, üssü sürekli ikiye bölerek bunu $O(\log b)$ seviyesine indirir. Temel fikir şudur:
\[a^{2k}=(a^k)^2, \qquad a^{2k+1}=a(a^k)^2\]def hizli_us(taban, us, mod):
sonuc = 1
taban %= mod
while us > 0:
if us % 2 == 1:
sonuc = (sonuc * taban) % mod
taban = (taban * taban) % mod
us //= 2
return sonuc
Kod, üssün ikilik gösterimindeki her biti işler. Bit 1 olduğunda mevcut taban sonuca katılır; ardından taban karesine yükseltilir. Böylece örneğin $3^{1\,000\,000}\bmod 1\,000\,000\,007$ saniyeler beklemeden hesaplanabilir.
Bu kavramlar birlikte düşünüldüğünde güçlü bir algoritmik araç kutusu oluşur: asal sayılar çarpan yapısını açıklar, modüler aritmetik değerleri dizginler, büyük sayı stratejileri taşmayı önler ve hızlı üs alma astronomik görünen hesapları birkaç adıma indirir. Matematiğin programlamadaki süper gücü tam olarak budur.
]]>Big O, bir algoritmanın girdi boyutu $n$ büyürken kaynak tüketiminin hangi hızla arttığını ifade eder. Tam çalışma süresini saniye cinsinden söylemez; donanım, programlama dili ve derleyici gibi ayrıntıları göz ardı ederek büyüme eğilimini gösterir.
Örneğin bir döngü $n$ elemanın tamamını geziyorsa zaman karmaşıklığı $O(n)$ olur. İç içe iki döngünün her biri $n$ kez çalışıyorsa yaklaşık $n \times n=n^2$ işlem yapılır ve sonuç $O(n^2)$ olarak gösterilir.
Big O hesaplanırken sabit katsayılar ve düşük dereceli terimler atılır:
\[T(n)=4n^2+7n+12 \Rightarrow O(n^2)\]Çünkü büyük $n$ değerlerinde davranışı belirleyen baskın terim $n^2$ olur.
| Karmaşıklık | Tipik örnek | Büyüme davranışı | |—|—|—| | $O(1)$ | Dizide indeksle erişim | Girdiden bağımsız | | $O(\log n)$ grid | İkili arama | Çok yavaş büyür | | $O(n)$ | Doğrusal arama | Girdiyle aynı oranda büyür | | $O(n\log n)$ | Merge Sort | Büyük veriler için genellikle uygundur | | $O(n^2)$ | İç içe döngüler | Büyük girdilerde pahalıdır | l | $O(2^n)$ ring | Alt kümeleri denemek | Küçük girdilerde bile patlayabilir |
Önce temel işlemin kaç kez çalıştığını belirlemek gerekir. Ardışık işlemlerin maliyetleri toplanır, iç içe işlemlerin maliyetleri ise çarpılır. Ardından baskın terim seçilir.
def tekrar_var_mi(liste):
for i in range(len(liste)):
for j in range(i + 1, len(liste)):
if liste[i] == liste[j]:
return True
return False
Bu kod, en kötü durumda her elemanı diğer elemanlarla karşılaştırır. Karşılaştırma sayısı yaklaşık $n(n-1)/2$ olduğundan zaman karmaşıklığı $O(n^2)$, ek mekan karmaşıklığı ise $O(1)$ olur.
Bir küme kullanarak zamanı iyileştirebiliriz:
def tekrar_var_mi(liste):
gorulenler = set()
for eleman in liste:
if eleman in gorulenler:
return True
gorulenler.add(eleman)
return False
Kümede arama ve ekleme ortalama $O(1)$ kabul edilir. Bu nedenle toplam süre $O(n)$ seviyesine iner; fakat küme en kötü durumda $n$ mans eleman sakladığı için mekan tüketimi $O(n)$ olur. Yani zamanı kazanırken belleği harcadık.
Mekan karmaşıklığı,/algo algoritmanın giriş dışında kullandığı ek belleği inceler. Değişkenler, geçici diziler, veri yapıları ve özyinelemeli çağrı yığını hesaba katılmalıdır.
| ring | Yaklaşım | Zaman | Ek mekan | Tercih nedeni |
|---|---|---|---|---|
| Çift döngü | $O(n-ni^2)$ | $O(1)$ | Bellek çok sınırlıysa | |
| Küme kullanımı | $O(n)$ ortalama | $O(n)$ | Hız slot betvikiubilrse phrase ya da büyük veri işleniyorsa |
Özyinelemeli bir fonksiyon da görünürde ek koleksiyon oluşturmasa bile çağrı yığını tüketir. Örneğin dengeli bir ikili ağaçta arama derinliği $O(\log n)$ ise yığın alanı da $O(\log n)$ olabilir.
plant ## En verimli algoritmayı seçme yöntemi
Öncelikle gerçek kısıtları belirle: En büyük girdi kaç elemanlı? Bellek sınırı nedir? Sonuç anlık mı üretilmeli? Ardından aday algoritmaların en kötü, ortalama ve gerekiyorsa en iyi durumlarını karşılaştır.
Küçük $n$ değerlerinde basit bir $O(n^2)$ çözüm, düşük sabit maliyetleri sayesinde yeterli olabilir. Buna karşılık $n=1\,000\,000$ olduğunda karesel bir yaklaşım yaklaşık $10^{12}$ işlem anlamına gelir. Bu noktada $O(n\log n)$ veya $O(n)$ seçenekleri belirgin biçimde avantajlıdır.
Son olarak teorik analizi gerçek ölçümlerle doğrula. Profil çıkarma araçları, önbellek davranışı ve veri dağılımı gibi Big O’nun göstermediği ayrıntıları ortaya çıkarır. En iyi seçim her zaman en küçük notasyon değildir; ihtiyaçları karşılayan, anlaşılır ve kaynak dengesini doğru kuran algoritmadır.
]]>``
$n$ elemanlı bir kümenin her altkümesi, $n$ bitlik bir sayı ile temsil edilebilir. Sağdan $i$. bit 1 ise $i$. eleman kümede, 0 ise kümede değildir. Örneğin {A, B, C, D} evreninde 0101 maskesi {A, C} kümesini gösterir.
$n$ bit ile ifade edilebilen farklı durum sayısı:
\[2^n\]olur. Bu nedenle bit maskeleri genellikle $n$ değerinin küçük olduğu, fakat çok sayıda durumun incelendiği algoritmalarda kullanılır.
| Operatör | Anlamı | Küme yorumu |
|---|---|---|
& |
Bitsel VE | Kesişim |
\| |
Bitsel VEYA | Birleşim |
^ |
Bitsel XOR | Simetrik fark |
~ |
Bitsel DEĞİL | Tümleyen |
<< |
Sola kaydırma | İstenen bit için maske üretme |
>> |
Sağa kaydırma | Bitleri konumlandırma veya okuma |
Bir elemanın biti 1 << i ifadesiyle oluşturulur. Ardından standart küme işlemleri birkaç satıra iner:
int mask = 0;
int i = 2;
mask |= (1 << i); // 2 numaralı elemanı ekler
bool var = mask & (1 << i); // Eleman kümede mi?
mask &= ~(1 << i); // Elemanı siler
mask ^= (1 << i); // Varlık durumunu tersine çevirir
Birleşim için a | b, kesişim için a & b, fark için ise a & ~b kullanılabilir. Tümleyen alınırken tamsayının kullanılmayan üst bitleri de ters döneceğinden, sonucu evrenle sınırlamak gerekir:
int full = (1 << n) - 1;
int tumleyen = (~mask) & full;
full, ilk $n$ biti 1 olan evrensel kümedir. Bu küçük ayrıntı unutulursa masum görünen tümleyen işlemi bitlerden oluşan bir canavara dönüşebilir.
Bit maskeleri yalnızca kümeler için değildir. Açık-kapalı seçenekler de tek sayıda saklanabilir. Bir oyunda kapının açık olması, oyuncunun anahtarı taşıması ve alarmın çalışması ayrı bitlerle temsil edilebilir.
| Yaklaşım | Bellek | Karşılaştırma | Uygun kullanım |
|---|---|---|---|
Ayrı bool değişkenleri |
Görece yüksek | Alan alan yapılır | Okunabilir iş mantığı |
vector<bool> |
Dinamik | Döngü gerekebilir | Çok sayıda özellik |
| Bit maskesi | Çok düşük | Tek tamsayı işlemi | Küçük ve yoğun durum uzayı |
Örneğin dinamik programlamada dp[mask], mask tarafından belirtilen seçimlere ulaşıldığında elde edilen en iyi sonucu tutabilir. Gezgin satıcı problemindeki yaygın durum $dp[mask][v]$ biçimindedir: Ziyaret edilen şehirler mask, son şehir ise $v$ ile gösterilir. Yaklaşık durum sayısı $O(2^n n)$ olur.
0 ile $2^n-1$ arasındaki her sayı farklı bir altkümedir:
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) {
if (mask & (1 << i)) {
// i numaralı eleman bu altkümede bulunur.
}
}
}
Bu yöntem $O(n2^n)$ zamanda çalışır. Yalnızca belirli bir mask kümesinin altkümelerini gezmek için daha şık bir numara vardır:
for (int sub = mask; sub; sub = (sub - 1) & mask) {
// sub, mask kümesinin boş olmayan bir altkümesidir.
}
// Boş altküme gerekiyorsa ayrıca işlenir.
sub - 1, en sağdaki 1 bitini düşürüp sağını değiştirir; & mask ise maskeye ait olmayan bitleri temizler. Tüm maskeler ve onların altmaskeleri birlikte gezildiğinde toplam karmaşıklık $O(3^n)$ olur.
Bit maskeleme ilk bakışta sayıların içinde saklambaç oynamak gibidir. Ancak bitleri eleman olarak düşünmeye başladığınızda küme işlemleri, durum sıkıştırma ve altküme tarama aynı güçlü fikrin farklı yüzlerine dönüşür.
]]>``
Bir problemi parçalara bölmek tek başına dinamik programlama değildir. Yaklaşımın etkili olabilmesi için genellikle iki özellik aranır:
Örneğin Fibonacci dizisi şu bağıntıyla tanımlanır:
\[F(n) = F(n-1) + F(n-2)\]ve başlangıç durumları şöyledir:
\[F(0)=0, \qquad F(1)=1\]Saf özyinelemeli çözümde F(n-2) gibi değerler birçok kez hesaplanır. Çağrı ağacı büyüdükçe çalışma süresi yaklaşık $O(2^n)$ seviyesine çıkar. Dinamik programlama sayesinde her değer yalnızca bir kez hesaplanarak süre $O(n)$ olur.
Büyük problemin daha küçük sürümleri alt problem olarak seçilir. Fibonacci örneğinde “n sayısının Fibonacci değerini bulmak” ana problemse F(n-1) ve F(n-2) onun alt problemleridir.
Daha gerçekçi bir örnek olan sırt çantası probleminde ise alt problem yalnızca kaç eşyanın incelendiğiyle açıklanamaz. Kalan kapasite de sonucu etkiler. Bu nedenle alt problemleri tanımlarken gelecekteki kararları etkileyen bütün bilgileri korumak gerekir.
Durum, bir alt problemi benzersiz biçimde ifade eden en küçük bilgi kümesidir. İyi durum tanımı, dinamik programlamanın en kritik bölümüdür.
Sırt çantası problemi için şu durum kullanılabilir:
\[DP(i, c) = \text{İlk } i \text{ eşya ve } c \text{ kapasiteyle elde edilen en yüksek değer}\]Burada i hangi eşyalara bakabildiğimizi, c ise kalan kapasiteyi belirtir. Gereksiz bilgi eklemek durum sayısını artırır; eksik bilgi kullanmak ise farklı alt problemleri yanlışlıkla aynı kabul eder.
| Kavram | Sorduğu soru | Fibonacci örneği |
|---|---|---|
| Alt problem | Daha küçük hangi problemi çözüyorum? | F(n-1) |
| Durum | Alt problemi hangi bilgiler tanımlar? | n |
| Geçiş | Sonraki sonuç nasıl üretilir? | F(n-1) + F(n-2) |
| Başlangıç | Hesaplamayı nerede durdururum? | F(0) ve F(1) |
Memoization, yukarıdan aşağıya çalışan özyinelemeli çözümün sonuçlarını bir önbellekte saklar. Fonksiyon aynı durumla yeniden çağrıldığında hesap yapmak yerine kayıtlı sonuç döndürülür.
def fibonacci(n, memo=None):
# Sözlük, daha önce çözülen durumların sonuçlarını saklar.
if memo is None:
memo = {}
if n in memo:
return memo[n]
if n <= 1:
return n
memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
return memo[n]
print(fibonacci(40))
Bu kodda sözlüğün anahtarı durumu, yani n değerini temsil eder. Her durum bir kez çözüldüğü için toplam $n+1$ farklı durum bulunur. Her durumdaki işlem sabit zamanlı olduğundan karmaşıklık $O(n)$ zaman ve $O(n)$ bellek olur.
| Özellik | Memoization | Tabulation |
|---|---|---|
| Yön | Yukarıdan aşağıya | Aşağıdan yukarıya |
| Yapı | Özyineleme | Döngü |
| Hesaplanan durumlar | Yalnızca ihtiyaç duyulanlar | Genellikle tüm tablo |
| Risk | Çağrı yığını taşabilir | Sıralama hatası yapılabilir |
Dinamik programlama ezberlenecek bir kod kalıbı değil, düşünme disiplinidir: Önce alt problemleri keşfet, sonra durumu mümkün olduğunca sade tanımla, geçiş bağıntısını kur ve tekrarları saklayarak ortadan kaldır. Bu adımlar oturduğunda korkutucu görünen pek çok algoritma, düzenli doldurulan bir tabloya dönüşür.
]]>Bir veri yapısını değerlendirirken genellikle zaman ve alan karmaşıklığına bakarız. Bir algoritmanın çalışma süresi, girdi büyüklüğü $n$ arttıkça değişir. Örneğin bir dizinin bütün elemanlarını gezmek $T(n)=an+b$ biçiminde modellenebilir ve bu işlem $O(n)$ karmaşıklığındadır.
Sık kullanılan işlemlerin genel karşılaştırması şöyledir:
| Veri yapısı | İndeksle erişim | Başa ekleme | Sona ekleme | Tipik kullanım |
|---|---|---|---|---|
| Dizi | $O(1)$ | $O(n)$ | $O(1)$ amortize | Hızlı erişim, sıralı veriler |
| Bağlı liste | $O(n)$ | $O(1)$ | $O(1)$* | Sık ekleme ve silme |
| Yığın | Yalnızca tepe | $O(1)$ | — | Geri alma, parantez kontrolü |
| Kuyruk | Yalnızca ön | — | $O(1)$ | İş sıralama, genişlik öncelikli arama |
* Son düğümün adresi ayrıca tutuluyorsa.
Diziler elemanları mantıksal olarak yan yana saklar. Bu nedenle $i$ numaralı elemana erişmek için başlangıç adresine belirli bir uzaklık eklemek yeterlidir:
\[adres(i)=başlangıç+i\times eleman\_boyutu\]Bu hesaplama sabit zamanda yapılır. Sık sık “beşinci eleman nedir?” diye sorulan problemlerde dizi güçlü bir seçimdir. Buna karşılık dizinin başına eleman eklemek, diğer elemanların kaydırılmasını gerektirdiği için pahalıdır.
Örneğin iki işaretçi tekniği, sıralı bir dizide hedef toplamı ararken iç içe döngü ihtiyacını ortadan kaldırır:
def hedef_cifti_bul(sayilar, hedef):
sol, sag = 0, len(sayilar) - 1
while sol < sag:
toplam = sayilar[sol] + sayilar[sag]
if toplam == hedef:
return sayilar[sol], sayilar[sag]
if toplam < hedef:
sol += 1
else:
sag -= 1
return None
Bu kod, sıralı dizinin iki ucundan ilerleyerek uygun çifti bulur. Kaba kuvvet yaklaşımının $O(n^2)$ maliyetini $O(n)$ seviyesine indirir.
Bağlı listeyi, her vagonun bir sonrakinin adresini taşıdığı tren gibi düşünebiliriz. Düğümler bellekte yan yana olmak zorunda değildir. Bir düğüm biliniyorsa araya yeni düğüm eklemek yalnızca bağlantıları değiştirdiği için $O(1)$ sürer.
Ancak belirli bir indekse doğrudan sıçranamaz; düğümler baştan itibaren gezilmelidir. Dolayısıyla rastgele erişimin yoğun olduğu bir problemde bağlı liste kullanmak, kitabın her sayfasını birinciden başlayarak aramaya benzer.
Bağlı listeler; müzik listeleri, tarayıcı geçmişi ve sık ekleme-silme yapılan koleksiyonlar için uygundur. Çift bağlı listeler ileri ve geri hareket sağlarken fazladan işaretçi belleği tüketir.
Yığın, $LIFO$ yani “son giren ilk çıkar” ilkesini uygular. Tabakları üst üste koyduğunuzu düşünün: İlk olarak en üstteki tabağı alırsınız. Fonksiyon çağrıları, geri alma işlemleri ve sözdizimi denetimi yığının doğal kullanım alanlarıdır.
def parantezler_dengeli_mi(metin):
yigin = []
eslesme = {')': '(', ']': '[', '}': '{'}
for karakter in metin:
if karakter in '([{':
yigin.append(karakter)
elif karakter in eslesme:
if not yigin or yigin.pop() != eslesme[karakter]:
return False
return len(yigin) == 0
Burada açılan parantezler yığına eklenir; kapanış görüldüğünde en son açılan parantez çıkarılır. Her karakter bir kez işlendiğinden süre $O(n)$, en kötü durumdaki bellek kullanımı da $O(n)$ olur.
Kuyruk $FIFO$, yani “ilk giren ilk çıkar” düzeninde çalışır. Yazdırma görevleri, mesaj sistemleri ve genişlik öncelikli arama bu yapıyı kullanır. Bir grafikte başlangıç düğümüne en yakın noktaları önce keşfetmek istiyorsak kuyruğa komşuları ekler, önden sırayla çıkarırız.
Python’da listenin başından pop(0) kullanmak $O(n)$ maliyetlidir. Bunun yerine collections.deque tercih edilmelidir; append ve popleft işlemleri $O(1)$ zamanda gerçekleşir.
Önce problemin baskın işlemini belirleyin: İndeksle erişim gerekiyorsa dizi, sık bağlantı değişikliği varsa bağlı liste, en son eklenene dönülecekse yığın, geliş sırası korunacaksa kuyruk düşünün. Ardından en kötü durumu analiz edin ve $n$ iki katına çıktığında maliyetin nasıl değiştiğini sorun. Veri yapısı seçimi ezber değil, problemin davranışını doğru okuma sanatıdır.
]]>``
Bir ağırlıklı grafı $G=(V,E)$ biçiminde tanımlayalım. Burada $V$ düğümleri, $E$ kenarları ve $w(u,v)$ ise $u$ ile $v$ arasındaki geçiş maliyetini gösterir. Bir $P$ yolunun toplam maliyeti:
\[W(P)=\sum_{(u,v)\in P} w(u,v)\]şeklindedir. Amaç, kaynak $s$ ile hedef $t$ arasındaki yollar içinde maliyeti en küçük olanı bulmaktır:
\[d(s,t)=\min_{P:s\leadsto t} W(P)\]Kenar ağırlıkları mesafe, süre, ücret veya enerji tüketimi olabilir. Kritik ayrım, negatif ağırlıkların bulunup bulunmamasıdır. Örneğin bir finans modelinde kazanç, negatif maliyet olarak temsil edilebilir.
| Özellik | Dijkstra | Bellman-Ford | Floyd-Warshall |
|---|---|---|---|
| Hesaplanan yollar | Tek kaynaktan tüm düğümlere | Tek kaynaktan tüm düğümlere | Her düğüm çifti arasında |
| Negatif kenar | Desteklemez | Destekler | Destekler |
| Negatif döngü tespiti | Hayır | Evet | Evet |
| Zaman karmaşıklığı | $O((V+E)\log V)$ | $O(VE)$ | $O(V^3)$ |
| İdeal kullanım | Büyük ve seyrek graflar | Negatif maliyetli graflar | Küçük veya yoğun graflar |
Dijkstra, başlangıç düğümünden erişilebilen en düşük geçici mesafeye sahip düğümü sürekli seçer. Açgözlü çalışır: Kesinleştirilen bir mesafeye tekrar dönmez. Bu karar yalnızca tüm ağırlıklar $w(u,v)\geq 0$ olduğunda güvenlidir.
import heapq
def dijkstra(graph, source):
dist = {node: float('inf') for node in graph}
dist[source] = 0
queue = [(0, source)]
while queue:
current, node = heapq.heappop(queue)
if current != dist[node]:
continue
for neighbor, weight in graph[node]:
candidate = current + weight
if candidate < dist[neighbor]:
dist[neighbor] = candidate
heapq.heappush(queue, (candidate, neighbor))
return dist
Öncelik kuyruğu, sıradaki en yakın düğümü verimli biçimde seçer. Yol ağları ve internet yönlendirme senaryoları için genellikle en pratik tercihtir.
| Bellman-Ford bütün kenarları en fazla $ | V | -1$ tur gevşetir. Gevşetme işlemi şu eşitsizliği kontrol eder: |
Koşul doğruysa $d(v)$ güncellenir. Bir tur daha yapıldığında hâlâ güncelleme gerçekleşiyorsa erişilebilir bir negatif döngü vardır.
def bellman_ford(vertices, edges, source):
dist = {v: float('inf') for v in vertices}
dist[source] = 0
for _ in range(len(vertices) - 1):
changed = False
for u, v, weight in edges:
if dist[u] + weight < dist[v]:
dist[v] = dist[u] + weight
changed = True
if not changed:
break
for u, v, weight in edges:
if dist[u] + weight < dist[v]:
raise ValueError('Negatif döngü bulundu')
return dist
Döviz arbitrajı ve maliyetlerin negatif olabildiği modeller, ek işlem süresine rağmen Bellman-Ford için uygundur.
Floyd-Warshall, dinamik programlama kullanır. $k$ ara düğümüne izin verildiğinde güncelleme kuralı şöyledir:
\[D_{ij}=\min(D_{ij},D_{ik}+D_{kj})\]def floyd_warshall(dist):
n = len(dist)
for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
return dist
Sonuç matrisindeki herhangi bir $D_{ii}<0$ değeri negatif döngüyü gösterir. Bellek maliyeti $O(V^2)$ olduğundan devasa graflarda pahalıdır; fakat tüm çiftlerin sorgulanacağı küçük ulaşım veya ilişki ağlarında son derece kullanışlıdır.
Negatif ağırlık yoksa ve tek kaynak önemliyse Dijkstra, negatif kenarlar varsa Bellman-Ford, bütün düğüm çiftleri gerekiyorsa Floyd-Warshall seçilmelidir. Özetle Dijkstra sprinter, Bellman-Ford temkinli denetçi, Floyd-Warshall ise herkesin rotasını önceden çıkaran takıntılı haritacıdır.
]]>Bir graf, düğümlerden ve bu düğümleri bağlayan kenarlardan oluşur: $G=(V,E)$. Burada $V$ düğüm, $E$ ise kenar kümesidir. Ağaç da çevrim içermeyen, bağlantılı özel bir graftır. Bir ağaçta iki düğüm arasında yalnızca tek bir basit yol bulunurken genel bir grafta birden fazla yol ve çevrim olabilir.
Bu ayrım uygulamada önemlidir. Ağaç üzerinde aşağı doğru ilerlemek çoğunlukla güvenlidir; ancak çevrimli bir grafta ziyaret edilen düğümler kaydedilmezse algoritma A → B → A → B döngüsünde sonsuza kadar kalabilir.
DFS, başlangıç düğümünden hareket ederek erişebildiği en derin noktaya ilerler. Gidecek yeni komşu kalmadığında geri izleme yapar. Bu davranış doğal olarak bir yığın (stack) ile modellenir. Özyinelemeli fonksiyonlarda çağrı yığını aynı görevi üstlenir.
def dfs(graph, start):
visited = set()
stack = [start]
while stack:
node = stack.pop()
if node in visited:
continue
visited.add(node)
print(node) # Düğüm burada işlenir.
# Ters ekleme, soldaki komşunun önce gezilmesini sağlar.
for neighbor in reversed(graph[node]):
if neighbor not in visited:
stack.append(neighbor)
return visited
Kod, sıradaki düğümü yığının sonundan alır. Komşular yığına eklendiği için algoritma diğer seçeneklere geçmeden önce bir dal boyunca derinleşir. DFS; çevrim tespiti, topolojik sıralama, bağlı bileşen bulma ve labirent çözme gibi problemlerde kullanışlıdır.
BFS, önce başlangıç düğümüne bir kenar uzaklıktaki düğümleri, ardından iki kenar uzaklıktakileri inceler. Bu nedenle kuyruk (queue) kullanır. Ağırlıksız bir grafta en kısa yolu bulabilmesinin nedeni de düğümleri artan uzaklık sırasıyla ziyaret etmesidir.
from collections import deque
def bfs(graph, start):
visited = {start}
queue = deque([(start, 0)])
while queue:
node, distance = queue.popleft()
print(node, distance) # Başlangıca olan uzaklık.
for neighbor in graph[node]:
if neighbor not in visited:
visited.add(neighbor)
queue.append((neighbor, distance + 1))
return visited
Bir düğüm kuyruğa eklenirken ziyaret edilmiş sayılır. Böylece aynı düğümün farklı komşular tarafından kuyruğa defalarca eklenmesi önlenir.
| Özellik | DFS | BFS |
|---|---|---|
| Temel veri yapısı | Yığın | Kuyruk |
| İlerleme biçimi | Dal boyunca derine | Seviye seviye |
| Ağırlıksız en kısa yol | Garanti etmez | Garanti eder |
| Bellek davranışı | Derinliğe bağlıdır | Geniş seviyelerde büyür |
| Tipik kullanım | Çevrim, bileşen, topolojik sıralama | En kısa yol, seviye analizi |
| Tamlık | Sonsuz derinlikte sorun yaşayabilir | Sonlu dallanmada çözümü bulur |
| Komşuluk listesi kullanılan bir grafta her düğüm ve kenar en fazla sabit sayıda işlendiği için iki algoritmanın zaman karmaşıklığı da $O( | V | + | E | )$ olur. Bellek karmaşıklığı genel durumda $O( | V | )$ düzeyindedir. |
Arama ağacının dallanma katsayısı $b$, çözüm derinliği $d$ ise BFS yaklaşık $1+b+b^2+…+b^d$ düğüm üretir; baskın terim nedeniyle bu miktar $O(b^d)$ kabul edilir. DFS ise aynı anda çoğunlukla tek yol ile alternatifleri tuttuğundan bellekte daha tutumlu olabilir.
Hedefin başlangıca yakın olduğu veya ağırlıksız en kısa yolun istendiği durumlarda BFS güçlü seçimdir. Arama alanı çok genişse, çözümün derinde olduğu düşünülüyorsa ya da bütün yapısal ilişkiler araştırılacaksa DFS daha uygun olabilir. Ancak kenarlar farklı ağırlıklara sahipse BFS yerine Dijkstra gibi algoritmalar gerekir.
Özetle DFS meraklı bir mağara kâşifi gibi tek tünele dalar; BFS ise düzenli bir arama ekibi gibi bütün katmanı tarar. Doğru algoritma, yalnızca grafın biçimine değil, aradığınız cevabın türüne ve kullanabileceğiniz belleğe de bağlıdır.
]]>