Aynı çizge (K_3,3), iki farklı çizim

• Eşbiçimliliği sınamak için DFS/BFS’den yararlanılır; ama genelde zor bir problemdir.
• Kenarları kesişmeden çizilebilen çizge düzlemseldir (planar). K_3,3 düzlemsel değildir: en az bir kesişme gerekir.
• Devre tasarımında: K_3,3 biçimli bir devre en az iki katman ister.

• Yönsüz çizgede kenarlar ağırlıklı olabilir: G(V, E) yerine G(V, E, w).
• Kapsayan ağaçlar içinde toplam kenar maliyeti en az olan(lar): minimum kapsayan ağaç.
• Ör. a: ağdaki kenar maliyetleri bilgisayarlar arası bağlantı maliyetidir.
• Ör. b: 7 köye elektrik/fiber optik: fizibilite hangi köyden hangisine kaç km kablo gerektiğini vermiş. Bağlantı olmayan köyler arası ∞ (yazılmıyor).

Örnek çizge

T = {};                    /* seçilen kenarlar */
while (|T| < n-1 && E ≠ Ø) {
    E'den en az maliyetli (v,w) kenarını seç;
    E = E - {(v,w)};
    if ((v,w) T içinde döngü oluşturmuyorsa)
        T = T ∪ {(v,w)};
    else
        (v,w)'yi bırak;
}
if (|T| < n-1)
    printf("minimum kapsayan ağaç yok\n");

• T: seçilen kenarlar, E: kalan kenarlar, |T|: seçilen kenar sayısı.
• Döngü n − 1 kenar seçilene kadar döner; henüz n − 1 seçilmemiş ama seçilebilecek kenar kalmamışsa da biter → çizge bağlantılı değildir.
• Kruskal’da seçilen kenarlar ayrık öbekler (orman) oluşturabilir; en sonda tek öbek olur.
• Joseph B. Kruskal, 1956; doğruluğunun ispatı vardır. “İspatı okununca daha iyi anlaşılır.”

• Gözlem: önce 2 bileşen oldu, sonra 3, sonra tekrar 2’ye düştü. “Yakaladık! Seçtiğim kenarları komşuluk listesinde tutarım.”
• Seçilmeyen kenarlar bir dizide. Kötü: her seferinde en azı ara, sil, kalanları kaydır. Daha iyi: kenarları maliyete göre sıralı tut (uç1, uç2, maliyet).
• (0,5) geldi: listelerde aratırım, ne 0 var ne 5 → yeni liste. (3,2), (6,1) de yeni listelere. (1,2): farklı listelerde → döngü yok, iki listeyi birleştir.
• (3,6): ikisi de aynı listede → döngü! Doğru çalışır ama sürekli bir arama maliyeti var.

typedef struct { int u, v, w; } kenar;

int kume_bul(int ata[], int i)   /* kok: ata < 0 */
{
    while (ata[i] >= 0) i = ata[i];
    return i;
}
void birlestir(int ata[], int a, int b)   /* a, b kok */
{
    if (ata[a] <= ata[b]) {   /* a daha buyuk kume */
        ata[a] += ata[b];  ata[b] = a;
    } else {
        ata[b] += ata[a];  ata[a] = b;
    }
}
int kars(const void *x, const void *y)
{
    return ((const kenar *)x)->w - ((const kenar *)y)->w;
}

• ata[i] < 0: i köktür ve −ata[i] küme boyutudur (başta hepsi −1).
• Ağırlıklı birleşim: küçük küme büyüğün altına bağlanır → ağaç yüksekliği O(log n), kume_bul O(log n).
• Yol sıkıştırma (path compression) da eklenirse işlem başına amortize ≈ O(α(n)) — pratikte sabit.
• kars: qsort için maliyet karşılaştırması (küçük tamsayılar; taşma yok).

T  = {};
TV = {0};           /* ağaç düğümleri: 0'dan başla */
while (|T| < n-1) {
    u ∈ TV ve v ∉ TV olan en ucuz (u,v) kenarını seç;
    if (böyle kenar yok) break;
    TV = TV ∪ {v};
    T  = T  ∪ {(u,v)};
}
if (|T| < n-1)
    printf("minimum kapsayan ağaç yok\n");

• Jarník (1930), Prim (1957), Dijkstra (1959) → DJP / Prim-Jarník algoritması.
• Kruskal’da ayrık kenarlar seçilebiliyordu; Prim seçilen kenarları tek öbek hâlinde büyütür.
• Seçilebilecek kenarlar: bir ucu TV’de, diğer ucu TV’de olmayan kenarlar.
• Tek bir öbek giderek büyür; döngü denetimi gerekmez (v ∉ TV zaten garanti eder).

• En az maliyetli aday kenar tek hamlede alınmalı.
• Bir kenar seçilince aday kümesine yeni kenarlar eklenir, bazıları çıkar (iki ucu da TV’ye düşenler): A kümesi B olur.
• 0 seçildiğinde yalnızca (0,1) ve (0,5)’i gören bir veri yapısı olmalı; diğerlerine bakmamalı bile.
• Çözüm (ek): her v ∉ TV için enaz[v] = TV’ye en ucuz bağlantı. Dizi ile O(n²); min-heap ile O(e log n).

/* komsuluk listesi + min-heap (anahtar = enaz) */
heap_ekle(H, 0, 0);
while (!heap_bos(H)) {
    u = heap_min_al(H);          /* O(log n) */
    if (secildi[u]) continue;    /* bayat kayit */
    secildi[u] = 1;
    for (p = baslik[u]; p; p = p->bag)
        if (!secildi[p->dugum] &&
            p->agirlik < enaz[p->dugum]) {
            enaz[p->dugum] = p->agirlik;
            yakin[p->dugum] = u;
            heap_ekle(H, p->dugum, p->agirlik);
        }
}

• Sollin / Borůvka (1926): her turda her bileşen en ucuz dış kenarını seçer; bileşen sayısı en az yarıya iner → en çok log n tur, O(e log n). Paralelleştirmeye uygundur.
• Reverse-delete: kenarlar azalan maliyetle denenir; kenarı silmek çizgeyi koparmıyorsa kenar silinir. Kruskal’ın tersi.
• Hepsi aynı kesit/döngü özelliklerine dayanır ve (farklı ağırlıklarda) aynı ağacı bulur.

Kruskal’ın kodlanması ödev olarak verildi; aşağıdaki soru sınavlarda sorulabilecek tarzdadır.

1. Kruskal ile MST’yi bulun; her kenar için “ekle / döngü” kararını yazın.
2. Prim’i A’dan başlatıp seçilen kenar sırasını yazın.
3. Union-find ata[] dizisinin son hâlini verin (ağırlıklı birleşim).