Bölüm 12: Açgözlü Algoritmalar

Bölüm 12: Açgözlü Algoritmalar · Çalışma Soruları
Açgözlü yaklaşımPara üstüEtkinlik seçimiİş sıralamaKesirli sırt çantasıUnion-Find ve KruskalBorůvkaHuffman kodlama
Sercan KÜLCÜ

Çoktan Seçmeli · Açgözlü Yaklaşım

Soru 1: Açgözlü Yaklaşımın Özü

Açgözlü algoritmalar için aşağıdakilerden hangisi doğrudur?

A: Açgözlü algoritma tek bir yerel en iyi seçim yapar ve geri dönüş yoktur. B dinamik programlamayı, C böl ve fethet yaklaşımını, D geri izlemeyi tanımlar. Bu yüzden açgözlü yöntem hızlıdır ama en iyi sonucu her problemde garanti etmez.

Çoktan Seçmeli · Açgözlü Yaklaşım

Soru 2: Açgözlü Seçim Özelliği

Bir problemin açgözlü seçim özelliği taşıması ne anlama gelir?

B: İlk açgözlü seçim hiçbir zaman "yanlış yola" sokmaz; bu genellikle değiştirme argümanıyla kanıtlanır. A, optimal alt yapının tanımıdır; açgözlü yöntemin doğru olması için ikisi birlikte gerekir. D, dinamik programlamanın özelliğidir.

Çıktı Sorusu · Para Üstü

Soru 3: Para Üstü Çıktısı

Para üstü metodu seçtiği her parayı yazdıracak biçimde değiştirildi. Program ne yazar? Bu sonuç bu para sistemi için en iyi midir?

static int paraUstu(int[] para, int tutar) {
  int adet = 0;
  for (int p : para) {
    while (tutar >= p) {
      tutar -= p;
      adet++;
      System.out.print(p + " ");
    }
  }
  return adet;
}
// main:
int[] para = {50, 25, 10, 5, 1};
int adet = paraUstu(para, 87);
System.out.println();
System.out.println(adet);
Cevabı göster

Çıktı: 50 25 10 1 1 ve alt satırda 5.

  • 87 → 50 (kalan 37) → 25 (12) → 10 (2) → 5 sığmaz → 1, 1 (0).
  • {50, 25, 10, 5, 1} kanonik bir para sistemidir: açgözlü sonuç her tutar için en iyidir (dinamik programlama da 5 bulur).
  • Süre O(k + adet): k = 5 para türü, 5 para seçildi.

Çoktan Seçmeli · Para Üstü

Soru 4: Kanonik Olmayan Para Sistemi

Paralar {10, 7, 1} ve tutar 15. Açgözlü para üstü algoritması kaç para verir; en iyi çözüm kaç paradır?

D: Açgözlü: 10 + 1 + 1 + 1 + 1 + 1 = 6 para. En iyi: 7 + 7 + 1 = 3 para. İlk seçim (10) küresel en iyiyi kaçırır; bu para sistemi açgözlü seçim özelliğini sağlamaz. Genel durumda dinamik programlama gerekir: enAz[t] = 1 + min enAz[t − p].

Adım Adım Çalıştırma · Para Üstü

Soru 5: Para Üstü İzleme

System.out.println(paraUstu(new int[]{4, 3, 1}, 10)) çağrısında hangi paralar seçilir ve ne yazdırılır?

kalan = 10

Paralar {4, 3, 1} (büyükten küçüğe), tutar 10. Turuncu çubuk kalan tutar; henüz para seçilmedi.

kalan = 64

p = 4: tutar ≥ 4 → 4 seçilir, kalan 6, adet 1.

kalan = 244

p = 4: tutar ≥ 4 → 4 seçilir, kalan 2, adet 2.

kalan = 244

p = 3: tutar = 2 < 3 → while hiç dönmez; 3 atlanır.

kalan = 1441

p = 1: tutar ≥ 1 → 1 seçilir, kalan 1, adet 3.

kalan = 04411

p = 1: tutar ≥ 1 → 1 seçilir, kalan 0, adet 4.

kalan = 04411

Döngü biter, 4 döner: 4 + 4 + 1 + 1. Oysa 4 + 3 + 3 yalnızca 3 paradır: ilk iki 4 seçimi en iyiyi kaçırdı.

static int paraUstu(int[] para, int tutar) {
  int adet = 0;
  for (int p : para) {
    while (tutar >= p) {
      tutar -= p;
      adet++;
    }
  }
  return adet;
}

Adım Adım Çalıştırma · Etkinlik Seçimi

Soru 6: Etkinlik Seçimi İzleme

Etkinlikler (s, f): (1,4), (3,5), (0,6), (5,7), (3,9), (5,9), (6,10), (8,11), (8,12), (2,14), (12,16); id'ler 1–11. sec(e) hangi etkinlikleri yazdırır?

02468101214161234567891011

Etkinlikler zaten bitişe göre sıralı (sort sırayı değiştirmez). En erken biten #1 [1, 4) seçilir; kesikli çizgi son seçilenin bitişi.

02468101214161234567891011

#2 [3, 5): 3 < 4 → çakışıyor, atlandı.

02468101214161234567891011

#3 [0, 6): 0 < 4 → çakışıyor, atlandı.

02468101214161234567891011

#4 [5, 7): 5 ≥ 4 → seçildi, i = 3.

02468101214161234567891011

#5 [3, 9): 3 < 7 → çakışıyor, atlandı.

02468101214161234567891011

#6 [5, 9): 5 < 7 → çakışıyor, atlandı.

02468101214161234567891011

#7 [6, 10): 6 < 7 → çakışıyor, atlandı.

02468101214161234567891011

#8 [8, 11): 8 ≥ 7 → seçildi, i = 7.

02468101214161234567891011

#9 [8, 12): 8 < 11 → çakışıyor, atlandı.

02468101214161234567891011

#10 [2, 14): 2 < 11 → çakışıyor, atlandı.

02468101214161234567891011

#11 [12, 16): 12 ≥ 11 → seçildi, i = 10. Sonuç: 4 etkinlik.

static void sec(Etkinlik[] e) {
  Arrays.sort(e, (x, y) ->
              x.bitis - y.bitis);
  int i = 0;              // son seçilen
  System.out.print(e[i].id + " ");
  for (int j = 1; j < e.length; j++) {
    if (e[j].bas >= e[i].bitis) {
      System.out.print(e[j].id + " ");
      i = j;
    }
  }
}

Çoktan Seçmeli · Etkinlik Seçimi

Soru 7: Doğru Ölçüt

Tek salonda birbiriyle çakışmayan en fazla sayıda etkinliği seçmek için hangi açgözlü ölçüt her zaman en iyi sonucu verir?

D: En erken biten etkinlik, kalan zamanı en çok bırakan seçimdir; değiştirme argümanı ile bu seçimi içeren bir en iyi çözüm olduğu gösterilir. En erken başlayan, uzun bir etkinliği seçip birçok kısa etkinliği engelleyebilir; en kısa ve en az çakışan ölçütlerinin de karşı örnekleri vardır.

Çıktı Sorusu · Etkinlik Seçimi

Soru 8: Yanlış Ölçütün Bedeli

Etkinlikler #1 [0, 10), #2 [1, 3), #3 [4, 6), #4 [7, 9). "En erken başlayan" ve "en erken biten" ölçütleriyle çalışan açgözlü algoritmalar kaçar etkinlik seçer?

#1[0, 10)#2[1, 3)#3[4, 6)#4[7, 9)0246810
Cevabı göster
  • En erken başlayan: #1 [0, 10) seçilir; diğer üçü onunla çakışır → 1 etkinlik.
  • En erken biten: #2 (bitiş 3) → #3 (4 ≥ 3) → #4 (7 ≥ 6); #1 çakışır → 3 etkinlik (en iyi).

Uzun bir etkinliğin erken başlaması, kalan zamanı tümüyle tüketebilir. Değiştirme argümanı: en iyi çözümün ilk etkinliği yerine en erken biteni koymak hiçbir çakışma yaratmaz, çünkü o daha erken (ya da aynı anda) biter.

Klasik Soru · Etkinlik Seçimi

Soru 9: Değiştirme Argümanı

Etkinlik seçiminde "en erken biten etkinliği seç" kuralının en iyi sonucu verdiğini değiştirme argümanıyla kanıtlayın.

Cevabı göster
  1. a₁ en erken biten etkinlik, O = {b₁, b₂, …, bk} bitişe göre sıralı bir en iyi çözüm olsun.
  2. b₁ = a₁ ise kanıt biter. Değilse O' = O − {b₁} ∪ {a₁} kurulur.
  3. f(a₁) ≤ f(b₁) ≤ s(b₂) olduğundan a₁, b₂ … bk ile çakışmaz: O' uygundur ve |O'| = |O| = k, yani O' de en iyidir.
  4. Demek ki a₁'i içeren bir en iyi çözüm vardır (açgözlü seçim özelliği). a₁ ve onunla çakışanlar atılınca kalan problem aynı türdendir (optimal alt yapı); tümevarımla her adımdaki seçim doğrudur.

Aynı kalıp Huffman ve Kruskal kanıtlarında da kullanılır: bir en iyi çözümü, daha kötü yapmadan açgözlü seçimi içerecek biçimde değiştirmek.

Adım Adım Çalıştırma · İş Sıralama

Soru 10: İş Sıralama İzleme

İşler (id, son tarih, kâr): (1, 2, 100), (2, 1, 19), (3, 2, 27), (4, 1, 25), (5, 3, 15). isSirala(is, 5) slotları nasıl doldurur, ne döndürür?

−1slot 1−1slot 2−1slot 3−1slot 4−1slot 5

Kâra göre azalan sıra: İş 1 (100), İş 3 (27), İş 4 (25), İş 2 (19), İş 5 (15). n = 5 slot, hepsi boş (−1).

−1slot 1İş 1slot 2−1slot 3−1slot 4−1slot 5

İş 1 (son tarih 2, kâr 100): en geç uygun slot 2 boş → yerleştirildi. toplam = 100.

İş 3slot 1İş 1slot 2−1slot 3−1slot 4−1slot 5

İş 3 (son tarih 2, kâr 27): slot 2 dolu, bir öncesine bakılır; slot 1 boş → yerleştirildi. toplam = 127.

İş 3slot 1İş 1slot 2−1slot 3−1slot 4−1slot 5

İş 4 (son tarih 1, kâr 25): slot 1'e kadar hepsi dolu → iş atlanır.

İş 3slot 1İş 1slot 2−1slot 3−1slot 4−1slot 5

İş 2 (son tarih 1, kâr 19): slot 1'e kadar hepsi dolu → iş atlanır.

İş 3slot 1İş 1slot 2İş 5slot 3−1slot 4−1slot 5

İş 5 (son tarih 3, kâr 15): en geç uygun slot 3 boş → yerleştirildi. toplam = 142.

İş 3slot 1İş 1slot 2İş 5slot 3−1slot 4−1slot 5

Sonuç: sırayla İş 3, İş 1, İş 5 yapılır; toplam kâr 142. İş 4 ve İş 2 son tarihine yetişemez.

static int isSirala(Is[] is, int n) {
  Arrays.sort(is, (a, b) -> b.kar - a.kar);
  int[] slot = new int[n];
  Arrays.fill(slot, -1); int toplam = 0;
  for (int i = 0; i < n; i++) {
    int j = Math.min(n, is[i].sonTarih) - 1;
    for (; j >= 0; j--) {
      if (slot[j] == -1) {
        slot[j] = is[i].id;
        toplam += is[i].kar;
        break;
      }
    }
  }
  return toplam;
}

Çoktan Seçmeli · İş Sıralama

Soru 11: En Geç Boş Slot

İş sıralama algoritması her işi son tarihinden önceki en geç boş slota koyar. Bunun nedeni nedir?

B: Bir işi gereğinden erken bir slota koymak, sonra gelecek ve son tarihi daha erken olan bir işin yerini kapatabilir. En geç boş slot seçimi esnekliği korur. Slot araması yine O(dmax) sürer (en kötü O(n²)); Union-Find ile neredeyse O(n)'e iner.

Çıktı Sorusu · Sırt Çantası

Soru 12: Kesirli Sırt Çantası

Nesneler (kâr, ağırlık): (24, 4), (18, 6), (30, 5), (10, 5), (12, 3); kapasite W = 15. Kesirli sırt çantası metodu ne yazdırır?

static double kesirli(int[][] n, int W) {
  // n[i] = {kâr, ağırlık}; orana göre azalan
  Arrays.sort(n, (a, b) -> Double.compare(
    (double) b[0] / b[1], (double) a[0] / a[1]));
  double deger = 0;
  for (int[] x : n) {
    if (W == 0) break;
    int al = Math.min(x[1], W);
    deger += (double) x[0] * al / x[1];
    W -= al;
  }
  return deger;
}
// main: n = {{24,4},{18,6},{30,5},{10,5},{12,3}}
System.out.println(kesirli(n, 15));
Cevabı göster

Çıktı: 75.0

nesne(24, 4)(30, 5)(12, 3)(18, 6)(10, 5)
oran66432
alınan4 (tümü)5 (tümü)3 (tümü)3/6—
kâr2430129—

24 + 30 + 12 + 9 = 75. Sıralama O(n log n), tek geçiş O(n). Eşit oranlı (24, 4) ve (30, 5) hangi sırada alınırsa alınsın sonuç değişmez.

Çoktan Seçmeli · Sırt Çantası

Soru 13: Oran Ölçütü ve 0/1

Kapasite W = 10; nesneler (kâr, ağırlık): X (30, 6), Y (20, 5), Z (20, 5). Kâr/ağırlık oranına göre açgözlü 0/1 seçim, en iyi 0/1 çözüm ve kesirli çözüm sırasıyla kaçtır?

C: Oranlar 5, 4, 4. Açgözlü X'i alır (6 kg); Y ve Z artık sığmaz → 30. En iyi 0/1: Y + Z = 40 (10 kg). Kesirli: X + Y'nin 4/5'i = 30 + 16 = 46. 0/1 sırt çantası açgözlü seçim özelliğini sağlamaz; dinamik programlama ile O(n·W) sürede çözülür.

Adım Adım Çalıştırma · Union-Find ve Kruskal

Soru 14: Union-Find İzleme

6 öğeli AyrikKume'de sırayla birlestir(0, 1), (2, 3), (1, 3), (4, 5), (5, 0) ve sonra bul(3) çalışıyor. ebeveyn ve rutbe nasıl değişir, bul(3) ne döndürür?

012345

AyrikKume(6): her öğe kendi kümesinin kökü; ebeveyn[i] = i, rütbeler 0.

012345

birlestir(0, 1): kökler 0 (rütbe 0) ve 1 (rütbe 0). Rütbeler eşit → ebeveyn[1] = 0, rutbe[0] = 1.

012345

birlestir(2, 3): kökler 2 (rütbe 0) ve 3 (rütbe 0). Rütbeler eşit → ebeveyn[3] = 2, rutbe[2] = 1.

012345

birlestir(1, 3): kökler 0 (rütbe 1) ve 2 (rütbe 1). Rütbeler eşit → ebeveyn[2] = 0, rutbe[0] = 2.

012345

birlestir(4, 5): kökler 4 (rütbe 0) ve 5 (rütbe 0). Rütbeler eşit → ebeveyn[5] = 4, rutbe[4] = 1.

012345

birlestir(5, 0): kökler 4 (rütbe 1) ve 0 (rütbe 2). Küçük rütbeli kök büyük olanın altına: ebeveyn[4] = 0.

012345

bul(3): 3 → 2 → 0 kök. Yol kısaltma dönüşte ebeveyn[3] = 0 yapar; sonraki bul(3) tek adımda biter. Ağaç yüksekliği rütbe sayesinde O(log n) kalır.

int bul(int x) {             // yol kısaltma
  if (ebeveyn[x] != x)
    ebeveyn[x] = bul(ebeveyn[x]);
  return ebeveyn[x];
}
void birlestir(int x, int y) {
  int kx = bul(x), ky = bul(y);
  if (kx == ky) return;
  if (rutbe[kx] < rutbe[ky]) {
    int t = kx; kx = ky; ky = t;
  }
  ebeveyn[ky] = kx;         // rütbeye göre
  if (rutbe[kx] == rutbe[ky]) rutbe[kx]++;
}

Çoktan Seçmeli · Union-Find ve Kruskal

Soru 15: Döngü Denetimi

Kruskal algoritmasında u–v kenarının döngü oluşturup oluşturmadığı nasıl denetlenmelidir?

B: Aynı kümedeki iki öğenin doğrudan ebeveynleri farklı olabilir (ör. 3 → 2 → 0 ve 1 → 0); yalnızca kökler karşılaştırılırsa doğru sonuç alınır. Kökler farklıysa kenar iki ayrı bileşeni bağlar ve döngü oluşmaz.

Adım Adım Çalıştırma · Union-Find ve Kruskal

Soru 16: Kruskal İzleme

kruskal(6, kenar) bu çizgede hangi kenarları ekler, hangilerini atlar, ne döndürür? (A…F = 0…5)

425634789ABCDEF

Kenarlar ağırlığa göre sıralandı (eşitlikte giriş sırası korunur): A–C 2, C–E 3, A–B 4, D–E 4, B–C 5, B–D 6, E–F 7, D–F 8, B–E 9. Her düğüm kendi kümesinde.

425634789ABCDEF

A–C (2): kökler farklı → eklendi. toplam = 2, sayac = 1.

425634789ABCDEF

C–E (3): kökler farklı → eklendi. toplam = 5, sayac = 2.

425634789ABCDEF

A–B (4): kökler farklı → eklendi. toplam = 9, sayac = 3.

425634789ABCDEF

D–E (4): kökler farklı → eklendi. toplam = 13, sayac = 4.

425634789ABCDEF

B–C (5): bul(B) = bul(C) → aynı küme; eklenirse döngü oluşur, atlanır.

425634789ABCDEF

B–D (6): bul(B) = bul(D) → aynı küme; eklenirse döngü oluşur, atlanır.

425634789ABCDEF

E–F (7): kökler farklı → eklendi. toplam = 20, sayac = 5. sayac = n − 1 → break.

425634789ABCDEF

MST: A–C, C–E, A–B, D–E, E–F → toplam 20. D–F (8) ve B–E (9) hiç incelenmedi.

static int kruskal(int n, int[][] kenar) {
  Arrays.sort(kenar, (x, y) -> x[2] - y[2]);
  AyrikKume kume = new AyrikKume(n);
  int toplam = 0, sayac = 0;
  for (int[] k : kenar) {
    int u = k[0], v = k[1], w = k[2];
    if (kume.bul(u) != kume.bul(v)) {
      kume.birlestir(u, v);
      toplam += w;
      sayac++;
      if (sayac == n - 1) break;
    }
  }
  return toplam;
}

Çoktan Seçmeli · Union-Find ve Kruskal

Soru 17: Kruskal'ın Maliyeti

Kruskal algoritmasının zaman karmaşıklığı O(E log E)'dir. Bu maliyetin baskın kaynağı hangi adımdır?

A: Sıralama O(E log E) = O(E log V) sürer (E ≤ V² olduğundan log E ≤ 2 log V). Yol kısaltma ve rütbeye göre birleştirme ile her bul/birlestir amortize O(α(V)), yani neredeyse sabittir. Kenarlar önceden sıralıysa algoritma neredeyse doğrusal çalışır.

Çoktan Seçmeli · Union-Find ve Kruskal

Soru 18: MST Hakkında Yanlış İfade

Minimum kapsayan ağaç (MST) hakkındaki ifadelerden hangisi yanlıştır?

D: Ağırlıkların hepsi farklıysa MST tektir; Prim ve Kruskal aynı ağacı bulur. Eşit ağırlıklarda farklı ağaçlar bulabilirler ama toplam ağırlık aynıdır. A doğrudur: her kapsayan ağaç V − 1 kenarlıdır, tüm toplamlar aynı miktar artar ve kenarların sırası değişmez. B doğrudur: Kruskal'da sıralama yönünü çevirmek yeterlidir.

Çıktı Sorusu · Union-Find ve Kruskal

Soru 19: Maksimum Kapsayan Ağaç

Kruskal algoritması, kenarlar azalan ağırlık sırasında işlenecek biçimde değiştirildi. Kruskal izleme sorusundaki çizgede hangi kenarlar hangi sırayla eklenir, hangileri reddedilir ve toplam ağırlık kaçtır?

425634789ABCDEF
Cevabı göster
  • Eklenenler: B–E 9, D–F 8, E–F 7, B–C 5, A–B 4.
  • Reddedilenler: B–D 6 (uçları zaten aynı bileşende).
  • Toplam 33; 5 kenar = V − 1 olunca durulur.

Yalnızca sıralama yönünü çevirmek yeterlidir. Alternatif: ağırlıkları −w yapıp normal Kruskal çalıştırmak.

Çıktı Sorusu · Borůvka

Soru 20: Borůvka'nın İlk Turu

Aynı çizgede Borůvka algoritmasının ilk turunda her düğüm hangi kenarı seçer? Tur sonunda kaç bileşen kalır ve toplam ağırlık nedir?

425634789ABCDEF
Cevabı göster
düğümen ucuz dış kenar
AA–C (2)
BA–B (4)
CA–C (2)
DD–E (4)
EC–E (3)
FE–F (7)
  • Farklı kenarlar: A–C, A–B, D–E, C–E, E–F → 5 kenar = V − 1.
  • Tek turda 1 bileşen kalır; toplam 20 (Kruskal ile aynı MST).
  • Aynı kenarı iki uç da seçebilir (A–C gibi); eklemeden önce bul ile denetlenir ki iki kez eklenmesin.

Çoktan Seçmeli · Borůvka

Soru 21: Borůvka Tur Sayısı

V = 1000 düğümlü bağlı bir çizgede (ağırlıklar farklı) Borůvka algoritması en fazla kaç tur sürer?

A: Her bileşen en az bir başka bileşenle birleştiği için her turda bileşen sayısı en az yarıya iner: ⌈log₂ 1000⌉ = 10 tur. Bir tur O(E) olduğundan toplam O(E log V). 999, her turda yalnızca bir kenar eklendiğini sanmaktan; 32 ise √1000'den gelir.

Çoktan Seçmeli · Borůvka

Soru 22: Kesim Özelliği

Düğümler S ve V − S diye iki kümeye ayrılıyor. Kesim özelliğine göre hangisi doğrudur (ağırlıklar farklı)?

C: Kesimi geçen en hafif kenar MST'dedir; Borůvka (her bileşenden çıkan en hafif kenar), Kruskal (iki bileşeni ayıran en hafif kenar) ve Prim bu özelliği kullanır. Kesimi geçen en ağır kenar, kesimi geçen tek kenarsa MST'dedir; bu yüzden A yanlıştır. B yanlıştır: çizgenin en hafif kenarı her zaman MST'dedir.

Adım Adım Çalıştırma · Huffman Kodlama

Soru 23: Huffman Ağacı İzleme

Frekanslar a:5, b:9, c:12, d:13, e:16, f:45. huffman(h, f) hangi birleştirmeleri yapar? Kodlar ve toplam bit sayısı ne olur?

a5b9c12d13e16f45

Her karakter frekansıyla bir yaprak olarak min-heap'e eklendi: a5, b9, c12, d13, e16, f45.

c12d13(14)e16f45

poll() iki kez: a5 ve b9 → yeni iç düğüm 14 = 5 + 9, kuyruğa eklenir.

(14)e16(25)f45

poll() iki kez: c12 ve d13 → yeni iç düğüm 25 = 12 + 13, kuyruğa eklenir.

(25)(30)f45

poll() iki kez: (14) ve e16 → yeni iç düğüm 30 = 14 + 16, kuyruğa eklenir.

f45(55)

poll() iki kez: (25) ve (30) → yeni iç düğüm 55 = 25 + 30, kuyruğa eklenir.

(100)

poll() iki kez: f45 ve (55) → yeni iç düğüm 100 = 45 + 55, kuyruğa eklenir.

(100)

Kök (100) döner. Sol 0, sağ 1: f = 0, c = 100, d = 101, a = 1100, b = 1101, e = 111. Toplam 45·1 + 12·3 + 13·3 + 5·4 + 9·4 + 16·3 = 224 bit (sabit 3 bitle 300).

static Dugum huffman(char[] h, int[] f) {
  PriorityQueue<Dugum> kuyruk =
    new PriorityQueue<>((a, b) -> a.f - b.f);
  for (int k = 0; k < h.length; k++)
    kuyruk.add(new Dugum(h[k], f[k]));
  while (kuyruk.size() > 1) {
    Dugum sol = kuyruk.poll();
    Dugum sag = kuyruk.poll();
    Dugum ata =
      new Dugum('\0', sol.f + sag.f);
    ata.sol = sol;
    ata.sag = sag;
    kuyruk.add(ata);
  }
  return kuyruk.poll();
}

Çıktı Sorusu · Huffman Kodlama

Soru 24: Huffman ile Çözme

Huffman ağacında sol kenar 0, sağ kenar 1'dir: F = 000, O = 001, E = 01, T = 10, G = 110, R = 111. 0110111001000 bit dizisi hangi metne çözülür? Aynı metin 3 bitlik sabit kodla kaç bit tutardı?

0101010101E5T7F2O3G4R4
Cevabı göster

Kökten başla, yaprağa gelince karakteri yaz ve köke dön:

01 | 10 | 111 | 001 | 000 → ETROF

  • Huffman: 13 bit; sabit kod: 5 × 3 = 15 bit.
  • Ayırıcı gerekmez: kodlar önek-özgürdür (her karakter bir yaprakta), bir kod bittiği an kesin olarak bilinir.
  • Çözücünün ağaca (ya da kod tablosuna) sahip olması gerekir; ağaç sıkıştırılmış veriyle birlikte gönderilir.

Çoktan Seçmeli · Huffman Kodlama

Soru 25: Önek-Özgür Kod

Aşağıdaki kod kümelerinden hangisi önek-özgürdür (hiçbir kod başka bir kodun öneki değildir)?

C: {0, 10, 110, 111}: hiçbiri diğerinin başlangıcı değildir; bu, bir ikili ağacın dört yaprağına karşılık gelir. A'da 0, 01'in önekidir ("01" → "ab" mi "b" mi?). B'de 1, 10'un; D'de 0, 00 ve 01'in önekidir.

Klasik Soru · Huffman Kodlama

Soru 26: ABRACADABRA

"ABRACADABRA" metnini Huffman ile kodlayın: frekansları, birleştirme sırasını, kod uzunluklarını ve toplam bit sayısını bulun. Sabit uzunluklu kodla karşılaştırın.

Cevabı göster

Frekanslar: A 5, B 2, R 2, C 1, D 1 (11 karakter).

  • C1 + D1 = 2 → B2 + R2 = 4 → (2) + (4) = 6 → A5 + (6) = 11.
  • Kod uzunlukları: A 1, B 3, R 3, C 3, D 3 → 5·1 + 2·3 + 2·3 + 1·3 + 1·3 = 23 bit.
  • Eşitlik başka türlü bozulursa (B2 + (2) birleşirse) uzunluklar A 1, R 2, B 3, C 4, D 4 olur: 5 + 4 + 6 + 4 + 4 = yine 23. Σ frekans · derinlik her Huffman ağacında aynıdır.

Sabit uzunluk: 5 karakter → 3 bit, 11 · 3 = 33 bit. Kazanç yaklaşık %30.

Çoktan Seçmeli · Huffman Kodlama

Soru 27: Huffman'ın Açgözlü Adımı

Huffman algoritmasının açgözlü adımı ve n karakter için karmaşıklığı (öncelikli kuyruk ile) nedir?

D: Her adımda en düşük frekanslı iki ağaç birleştirilir; bu karakterler en derinde kardeş olur. n − 1 birleştirme, her biri O(log n) heap işlemi → O(n log n). Doğruluk: en düşük frekanslı iki karakterin en derinde kardeş olduğu bir en iyi ağaç vardır (değiştirme argümanı).

Son

Bölüm 12: Açgözlü Algoritmalar: Çalışma Soruları
Konu anlatımı: Açgözlü algoritmalar sunumu · Terim sözlüğü
1 / 1 Sercan KÜLCÜ, Tüm hakları saklıdır.