Sebuah Pohon Perentang (Spanning Tree, ST) dari sebuah graf terhubung tak-terarah berbobot G adalah sebuah sub-graf dari G yang merupakan sebuah pohon dan menghubungkan (merentangi) semua simpul-simpul dari G. Sebuah graf G dapat memiliki lebih dari satu ST (lihat ini atau ini), masing-masing dengan bobot total (jumlah dari bobot-bobot sisi dalam ST) yang berbeda.

Problem MST adalah sebuah masalah standar graf (dan juga masalah optimisasi) yang didefinisikan sebagai berikut: Diberikan sebuah graf terhubung tidak-berarah berbobot G = (V, E), pilihlah sebuah subset dari sisi-sisi dari G sehingga grafnya tetap terhubung tetapi dengan total bobot terkecil. Keluarannya antara MST sesungguhnya dari G (bisa ada beberapa MST-MST yang memungkinkan dari G) atau biasanya hanya total bobot minimum itu saja (nilai ini unik).

Pemerintah mau mengkoneksikan N desa-desa di sebuah negara dengan N-1 jalan-jalan.
(yaitu sebuah pohon perentang dengan N simpul-simpul dan N-1 sisi-sisi).

Biaya untuk membuat sebuah jalan untuk mengkoneksikan dua pedesaan tergantung medan, jarak, dsb.
(yaitu graf komplit tidak-berarah berbobot dengan N*(N-1)/2 sisi-sisi berbobot).

Anda mau meminimalkan biaya total pembangunan. Bagaimana anda akan membangun jalan-jalan tersebut?
(yaitu pohon perentang minimum).

Catatan: Ada varian dari masalah ini yang membutuhkan solusi tingkat lanjut, misalkan lihat ini.

Masalah MST ini memiliki solusi-solusi polinomial.

Dalam visualisasi ini, kita akan mempelajari dua diantaranya: Algoritma Kruskal dan algoritma Prim. Keduanya diklasifikasikan sebagai Algoritma Rakus (Greedy). Catat bahwa ada algoritma-algoritma MST lainnya diluar dua yang dipresentasikan disini.

Lihat visualisasi algoritma MST diatas.

Terdapat dua sumber berbeda untuk menspesifikasikan graf masukan:

Algoritma Kruskal: Sebuah algoritma MST greedy O(E log V) yang menumbuhkan sebuah kumpulan hutan (forest) dari pohon-pohon perentang minimum dan kemudian menggabungkan semuanya menjadi sebuah MST.

Algoritma Kruskal pertama-tama mengurutkan himpunan sisi-sisi E dalam bobot yang tidak-menurun (bisa ada sisi-sisi yang memiliki bobot yang sama), dan jika ada seri, berdasarkan nomor simpul yang lebih kecil secara menaik, dan jika tetap seri, by nomor simpul yang lebih besar secara menaik dari sisi tersebut.

Diskusi: Apakah ini adalah satu-satunya kriteria pengurutan yang memungkinkan?

Lalu, algoritma Kruskal akan melakukan perulangan melalui sisi-sisi yang telah diurutkan ini (menurut properti bobot yang tidak-menurun) dan secara rakus (greedy) mengambil sisi e berikutnya jika sisi tersebut tidak membuat siklus apapun terhadap sisi-sisi yang telah diambil sebelumnya.

Tanpa basa-basi, mari coba Kruskal pada graf contoh default (yang memiliki tiga sisi-sisi dengan bobot yang sama). Jalani contoh animasi ini terlebih dahulu sebelum melanjutkan.

Untuk melihat kenapa Strategi Rakus dari algoritma Kruskal bekerja, kita definisikan sebuah invarian perulangan: Setiap sisi e yang ditambahkan kedalam pohon T oleh algoritma Kruskal pastilah bagian dari MST.

Pada permulaan perulangan utama Kruskal, T = {} selalu adalah bagian dari MST secara definisi.

Kruskal memiliki pengecekan siklus spesial dalam perulangan utamanya (menggunakan struktur data UFDS) dan hanya menambahkan sebuah sisi e kedalam T jika sisi tersebut tidak akan membuat sebuah siklus terhadap sisi-sisi lainnya yang telah dipilih sebelumnya.

Pada akhir dari perulangan utama, Kruskal hanya bisa memilih V-1 sisi-sisi dari sebuah graf terhubung tidak-terarah berbobot G tanpa menjumpai siklus apapun. Ini menyiratkan bahwa Kruskal memprodkusi Pohon Perentang.

Pada contoh default, sadari bahwa setelah mengambil 2 sisi-sisi pertama: 0-1 dan 0-3, begitu urutannya, Kruskal tidak dapat mengambil sisi 1-3 karena sisi tersebut akan menyebabkan siklus 0-1-3-0. Kruskal lalu mengambil sisi 0-2 tetapi tidak dapat mengambil sisi 2-3 karena itu akan menyebabkan siklus 0-2-3-0.

Kita telah melihat di slide sebelumnya bahwa algoritma Kruskal akan membuat sebuah pohon T yang adalah Pohon Perentang Spanning Tree (ST) ketika algoritma itu berhenti. Tetapi apakah pohon itu ST yang paling minimum, yaitu MST?

Untuk membuktikan ini, kita perlu mengingat bahwa sebelum menjalankan perulangan utama Kruskal, kita telah mengurutkan sisi-sisi berdasarkan bobot yang tidak-menurun, yaitu sisi-sisi yang muncul belakangan akan memiliki bobot yang sama atau lebih besar daripada sisi-sisi yang muncul sebelumnya.

Pada permulaan setiap perulangan, T selalu bagian dari MST.

Jika Kruskal hanya menambahkan sisi legal e (yang tidak akan menyebabkan siklus terhadap sisi-sisi yang telah diambil sebelumnya) dengan biaya minimal, maka kita bisa yakin bahwa w(T U e) ≤ w(T U sisi e' apapun lainnya yang belum diproses yang tidak menyebabkan siklus) (karena Kruskal telah mengurutkan sisi-sisi tersebut, jadi w(e) ≤ w(e')).

Oleh karena itu, pada akhir dari perulangan, Pohon Perentang T haruslah memiliki bobot keseluruhan minimal w(T), jadi T adalah MST finalnya.

Pada contoh default, sadari bahwa setelah mengambil 2 sisi-sisi pertama: 0-1 dan 0-3, begitu urutannya, dan mengabaikan sisi 1-3 karena sisi tersebut akan menyebabkan siklus 0-1-3-0, kita dapat dengan aman mengambil sisi terkecil legal berikutnya 0-2 (dengan bobot 2) karena mengambil sisi legal lainnya (misalkan sisi 2-3 dengan bobot lebih besar 3) akan membuat MST lain dengan bobot sama (bukan dalam contoh ini) atau ST lainnya yang bukan minimum (yang terjadi dalam contoh ini).

Ada dua bagian-bagian dari algoritma Kruskal: Pengurutan dan pengulangan utama Kruskal.

Pengurutan sisi-sisi mudah saja. Kita simpan grafnya dengan menggunakan struktur data Daftar Sisi dan mengurutkan E sisi-sisi menggunakan O(E log E) = O(E log V) algoritma pengurutan (atau cukup gunakan C++/Python/Java perpustakaan rutin pengurutan) berdasarkan bobot yang tidak-menurun, nomor simpul yang lebih kecil, nomor simpul yang lebih besar. O(E log V) ini adalah is the bagian paling besar dari algoritma Kruskal karena bagian kedua sebenarnya lebih ringan, lihat dibawah.

Perulangan utama Kruskal bisa dengan mudah diimplementasikan emnggunakan struktur data Himpunan Lepas (Union-Find Disjoint Sets). Kita menggunakan IsSameSet(u, v) untuk menguji apakah jika mengambil sisi e dengan dua ujung u dan v akan menyebabkan sebuah siklus (komponen terhubung yang sama -- ada jalur lain di sub-pohon yang bisa menghubungkan u ke v, sehingga menambahkan sisi (u, v) akan menyebabkan sebuah siklus) atau tidak. Jika IsSameSet(u, v) mengembalikan salah, kita dengan rakus mengambil sisi e terkecil dan legal selanjutnya dan memanggil UnionSet(u, v) untuk mencegah siklus-siklus di masa mendatang yang berhubungan dengan sisi ini. Bagian ini berjalan dalam O(E) karena kita mengasumsikan bahwa operasi-operasi UFDS IsSameSet(u, v) dan UnionSet(u, v) berjalan dalam O(1) untuk graf yang secara relatif kecil.

Algoritma Prim: Sebuah algoritma MST greedy O(E log V) lain yang mengembangkan sebuah Pohon Perentang Minimum (Minimum Spanning Tree, MST) mulai dari sebuah simpul sumber sampai Pohon tersebut melingkupi keseluruhan graf.

Algoritma Prim membutuhkan struktur data Antrean Berprioritas (Priority Queue, PQ) (yang biasanya diimplementasikan menggunakan Timbunan Biner tetapi kita juga bisa menggunkan Pohon Pencarian Biner Seimbang juga) untuk mengurutkan secara dinamis sisi-sisi yang sedang dipertimbangkan berdasarkan bobot yang tidak-menurun, sebuah struktur data Daftar Adjacency (Adjacency List) untuk enumerasi cepat tetangga-tetangga dari sebuah simpul, dan larik Boolean untuk membantu dalam pengecekan siklus.

Nama lain dari algoritma Prim adalah algoritma Jarnik-Prim.

Algoritma Prim dimulai dari sebuah simpul sumber s yang ditentukan (biasanya simpul 0) dan mengantrikan semua sisi-sisi yang bersinggungan dengan s kedalam sebuah Antrean Berprioritas (Priority Queue, PQ) sesuai bobot yang tidak-menurun, dan jika seri, berdasarkan nomor simpul menaik (dari nomor simpul tetangga). Lalu Prim akan secara berulang melakukan langkah-langkah rakus (greedy) berikut: Jika simpul v dari informasi pasangan sisi yang paling depan e: (w, v) didalam PQ belum pernah dikunjungi, itu berarti bahwa kita bisa secara rakus meluaskan pohon T untuk mencakup simpul v dan mengantrikan sisi-sisi yang terhubung dengan v kedalam PQ, jika tidak kita membuang sisi e (karena Prim menumbuhkan pohon perentang dari s, fakta bahwa v telah dikunjungi mengimplikasikan bahwa ada jalur lain dari s ke v dan menambahkan sisi ini akan membuat sebuah siklus).

Tanpa basa basi, mari coba Prim(1) pada graf contoh default (yang memiliki tiga sisi-sisi dengan bobot yang sama). Yaitu, kita memulai algoritma Prim dari simpul sumber s = 1. Jalani contoh animasi ini terlebih dahulu sebelum melanjutkan.

Algoritma Prim adalah sebuah Algoritma Rakus (Greedy) karena pada setiap langkah dari perulangan utamanya, algoritma ini selalu berusaha untuk memilih sisi valid e berikutnya dengan bobot minimal (ini rakus (greedy)!).

Untuk meyakinkan kita bahwa algoritma Prim adalah benar, mari lakukan pembuktian sederhana berikut: Biarkan T adalah pohon perentang dari graf G yang dibuat oleh algoritma Prim dan T* adalah pohon perentang dari G yang diketahui memiliki ongkos minimal, yaitu T* adalah MST.

Jika T == T*, yaitu algorima Prim membuat MST yang sama dengan T*, maka kita selesai.

Tetapi jika T != T*...

Asumsikan bahwa pada contoh default, T = {0-1, 0-3, 0-2} tetapi T* = {0-1, 1-3, 0-2}.

Biarkan e_k = (u, v) adalah sisi pertama yang dipilih oleh Algoritma Prim pada iterasi ke-k yang tidak berada dalam T* (pada contoh default, k = 2, e₂ = (0, 3), catat bahwa (0, 3) tidak ada dalam T*).

Biarkan P adalah jalur dari u ke v dalam T*, dan biarkan e* menjadi sisi di P sehingga satu titik akhir ada di pohon yang dibuat pada iterasi ke-(k−1) dari algoritma Prim dan titik akhir satu lagi tidak (pada contoh default, P = 0-1-3 dan e* = (1, 3), catat bahwa simpul 1 berada didalam T pada iterasi pertama k = 1).

Jika bobot dari e* kurang dari bobot e_k, maka algoritma Prim pastilah telah memilih e* pada iterase ke-k karena begitulah cara kerja algoritma Prim.

Jadi, kita yakin bahwa w(e*) ≥ w(e_k).
(pada graf contoh, e* = (1, 3) memiliki bobot 1 dan e_k = (0, 3) juga memiliki bobot 1).

Ketika bobot e* sama dengan bobot e_k, maka sebenarnya kita bisa saja memilih e* atau e_k. Dan ketika bobot dari e* adalah ≥ bobot dari e_k, e* selalu dapat disubstitusikan dengan e_k sementara menjaga total bobot minimal dari T*. (pada graf contoh, ketika kita mengganti e* = (1, 3) dengan e_k = (0, 3), kita berhasil mentransformasikan T* menjadi T).

Tetapi jika T != T*... (dilanjutkan)

Kita dapat mengulang proses substitusi yang dijelaskan sebelumnya berulang kali sampai T* = T dan pada saat itu kita telah menunjukkan bahwa pohon perentang yang dibuat oleh setiap instansi dari algoritma Prim (dari simpul sumber s apapun) adalah sebuah MST karena apapun MST optimalnya, MST optimal tersebut bisa ditransformasikan menjadi keluaran dari algoritma Prim.

Kita bisa dengan mudah mengimplementasikan algoritma Prim dengan dua struktur-struktur data yang cukup terkenal:

1. Sebuah Antrean Berprioritas (Priority Queue PQ) (Tumpukan Biner didalam C++ STL priority_queue/Python heapq/Java PriorityQueue atau BST Seimbang didalam C++ STL set/Java TreeSet), dan
2. Sebuah larik Boolean dengan ukuran V, pada dasarnya adalah Tabel Pengalamatan Langsung (untuk menentukan apakah sebuah simpul telah diambil atau tidak, yaitu di dalam komponen terhubung yang sama dengan simpul sumber s atau tidak).

Dengan ini, kita bisa menjalankan Algoritma Prim dalam O(E log V) karena kita memproses setiap sisi sekali saja dan setiap kali, kita memanggil Masukkan((w, v)) dan (w, v) = EkstrakMaks() dari sebuah PQ dalam O(log E) = O(log V²) = O(2 log V) = O(log V). Karena ada E sisi-sisi, Algoritma Prim berjalan dalam O(E log V).

Quiz: Having seen both Kruskal's and Prim's Algorithms, which one is the better MST algorithm?

Diskusi: Kenapa?

Anda telah mencapai akhir dari materi-materi sederhana masalah graf Pohon Perentang Minimum (Min Spanning Tree, MST) dan dua algoritma-algoritma klasiknya: Kruskal dan Prim (ada yang lain, seperti O(E log V) yang lain yaitu Boruvka, tetapi tidak dibahas di visualisasi ini). Kami menyarankan anda untuk menjelajahi lebih lanjut di Mode Eksplorasi.

Tetapi, masalah-masalah MST yang lebih sulit bisa (jauh) lebih menantang dari versi dasarnya.

Saat anda lebih menguasai topik MST ini, kami menyemangati anda untuk mempelajari masalah-masalah graf yang lebih sulit dimana MST digunakan sebagai salah satu komponennya, misalkan algoritma aproksimasi untuk masalah-masalah NP-hard (Metric No-Repeat) TSP dan Pohon Steiner.

Kami menulis beberapa varian-varian masalah MST di buku Competitive Programming.

1. Pohon Perentang Maks(imum),
2. Subgraf Perentang Min(imum),
3. Hutan Perentang Min(imum),
4. Pohon Perentang Kedua Terbaik,
5. Masalah Jalur Minimax (Maximin), dsb

Iklan: Belilah buku CP untuk mempelajari lebih lanjut tentang varian-varian ini dan lihatlah bahwa kadang-kadang Kruskal lebih baik dan kadang-kadang Prim lebih baik pada beberapa dari varian-varian ini.

Untuk beberapa pertanyaan-pertanyaan yang lebih menantang tentang masalah MST dan/atau Algoritma-Algoritma Kruskal/Prim, silahkan latihan pada modul latihan MST (tidak perlu login, tetapi hanya pada setingan kesulitan medium saja).

Tetapi, untuk murid-murid NUS, anda harus login untuk secara ofisial menyelesaikan modul ini dan penghargaan tersebut akan dicatat pada akun pengguna anda.

Masalah MST ini bisa jauh lebih susah daripada bentuk dasar ini. Oleh karena itu kami menganjurkan anda untuk mencoba dua masalah-masalah kontes ACM ICPC mengenai MST: UVa 01234 - RACING dan Kattis - arcticnetwork.

Cobalah mereka untuk mengkonsolidasi dan meningkatkan pengertian anda tentang masalah graf ini.

Anda diijinkan untuk menggunakan/memodifikasi kode implementasi kami untuk algoritma-algoritma Kruskal/Prim:
kruskal.cpp | py | java | ml
prim.cpp | py | java | ml