PRAKTIKUM MODUL 9

GRAPH
Dyah Puteria Wati, M.Kom

Disusun Oleh :

Nama : Imas imaniar

NIM : 20220910019
Kelas : SINFC-2022-03

FAKULTAS ILMU KOMPUTER

PROGRAM STUDI SISTEM INFORMASI
UNIVERSITAS KUNINGAN
2023
Pree Test

1. Sebutkan algoritma yang menerapkan konsep graph !

Jawab :
Algoritma Depth-First Search (DFS) adalah algoritma pencarian dalam graf yang
digunakan untuk menemukan semua simpul dalam graf yang dapat dicapai dari simpul
awal (source node). Algoritma ini bekerja dengan mengunjungi simpul-simpul secara
mendalam sejauh mungkin sebelum kembali ke simpul sebelumnya dan melanjutkan ke
simpul lain yang belum dieksplorasi.

Prinsip kerja algoritma DFS adalah sebagai berikut:

1. Mulai dari simpul awal, tandai simpul tersebut sebagai sudah dikunjungi.
2. Periksa semua tetangga (simpul terhubung) dari simpul saat ini yang belum
dikunjungi.
3. Pilih salah satu tetangga yang belum dikunjungi dan rekursif lakukan pencarian DFS
pada simpul tersebut.
4. Terus ulangi langkah 2-3 untuk semua tetangga yang belum dikunjungi sampai tidak
ada tetangga yang tersisa atau semua simpul telah dikunjungi.
5. Kembali ke simpul sebelumnya dan periksa tetangga-tetangga yang belum dikunjungi.
6. Ulangi langkah 2-5 sampai semua simpul yang dapat dicapai telah dikunjungi.

Algoritma DFS umumnya menggunakan stack (tumpukan) untuk melacak simpul-simpul

yang akan dieksplorasi. Ketika simpul saat ini dieksplorasi, tetangga-tetangganya
ditambahkan ke stack untuk dieksplorasi selanjutnya.

DFS biasanya digunakan untuk mencari jalur atau menjelajahi seluruh struktur graf.
Algoritma ini berguna dalam mencari jalur terpendek, memeriksa keterhubungan graf,
menemukan siklus, dan masalah-masalah lain yang melibatkan pencarian dalam graf.

2. Jelaskan langkah-langkah algoritma yang telah disebutkan dijalankan !

Jawab :

Berikut adalah langkah-langkah dari algoritma DFS:

1. Inisialisasi:
 Tentukan simpul awal (source node) sebagai titik awal pencarian.
 Buat sebuah himpunan untuk menyimpan simpul-simpul yang telah dikunjungi
dan tambahkan simpul awal ke dalamnya.

2. Pencarian:
Lakukan langkah-langkah berikut:
 Tandai simpul saat ini sebagai sudah dikunjungi.
 Periksa semua tetangga (simpul terhubung) dari simpul saat ini yang belum
dikunjungi.
  Jika ditemukan simpul yang belum dikunjungi, rekursif melakukan pencarian DFS
pada simpul tersebut.
 Ulangi langkah ini untuk semua tetangga simpul saat ini.

3. Hasil:
 Setelah semua simpul yang dapat dicapai telah dikunjungi, pencarian DFS selesai.
 Semua simpul yang dapat dicapai dari simpul awal telah dikunjungi.

Algoritma ini mengeksplorasi jalur tertentu sejauh mungkin sebelum kembali ke simpul
sebelumnya dan mencari jalur lain yang belum dieksplorasi.

3. Buatlah studi kasus yang sesuai dengan algoritma yang disebutkan pada nomor 1 !
Jawab :

Studi Kasus: Penjelajahan Labirin

Misalkan kita berada di dalam sebuah labirin dengan lorong-lorong yang saling
terhubung. Kita ingin menemukan jalan keluar dari labirin tersebut menggunakan
algoritma Depth-First Search (DFS).

Langkah-langkah algoritma Depth-First Search (DFS) pada studi kasus ini:

1. Inisialisasi:
 Pilih posisi awal kita sebagai titik awal pencarian.
 Buat sebuah himpunan yang berisi posisi-posisi yang telah kita kunjungi dan
tambahkan posisi awal ke dalamnya.

2. Pencarian:
 Pada posisi saat ini, tandai posisi tersebut sebagai sudah dikunjungi.
 Periksa semua lorong yang terhubung dari posisi saat ini yang belum dikunjungi.
 Jika ditemukan lorong yang belum dikunjungi, pilih salah satu lorong tersebut dan
rekursif lakukan pencarian DFS dari posisi lorong tersebut.
 Ulangi langkah ini untuk semua lorong yang terhubung dari posisi saat ini.

3. Hasil:
 Setelah semua posisi yang dapat dicapai telah dikunjungi, pencarian DFS selesai.
 Kita akan menemukan jalan keluar dari labirin jika ada, atau akan mencapai titik
buntu jika tidak ada jalan keluar.

Untuk hasil dari algoritma Depth-First Search (DFS) pada studi kasus ini adalah urutan
posisi-posisi yang kita kunjungi selama penjelajahan labirin. Algoritma ini akan
mengeksplorasi satu lorong sampai titik buntu sebelum kembali ke posisi sebelumnya dan
mencari lorong lain yang belum dieksplorasi. Dengan menggunakan algoritma DFS, kita
akan dapat menemukan jalan keluar dari labirin jika ada.
Praktikum

Studi Kasus 9.1

Studi kasusnya suatu jaringan sosial atau jaringan transportasi. Misalnya, pada jaringan
sosial, setiap orang diwakili oleh node dan adanya hubungan pertemanan antara mereka
dapat direpresentasikan dengan adanya edge di antara node-node tersebut.Sedangkan pada
jaringan transportasi, setiap kota atau tempat diwakili oleh node dan adanya jalan atau jalur
transportasi antara kota-kota dapat direpresentasikan dengan adanya edge di antara node-
node tersebut.

Dibawah ini program penyelesaian studi kasus-9.1

#include <iostream>

#include <vector>

using namespace std;

const int MAXN = 100; // jumlah maksimum node

vector<int> adj[MAXN + 1]; // adjacency list

int main()

int n, m; // jumlah node dan jumlah edge

cin >> n >> m;

for (int i = 1; i <= m; i++)

int u, v; // node awal dan node tujuan

cin >> u >> v;

adj[u].push_back(v); // tambahkan edge dari u ke v

adj[v].push_back(u); // tambahkan edge dari v ke u

// cetak adjacency list

 for (int i = 1; i <= n; i++)

cout << "Node " << i << ": ";

for (int j = 0; j < adj[i].size(); j++)

cout << adj[i][j] << " ";

cout << endl;

return 0;

Hasil runnya :

Analisis :

Program di atas merupakan implementasi sederhana dari struktur data adjacency list untuk
merepresentasikan sebuah graf tak berarah. Program ini menggunakan library iostream dan
vector untuk mengelola daftar adjacency.

1. Pada variabel n dan m dideklarasikan untuk menyimpan jumlah node dan jumlah edge
dalam graf. Nilai-nilai ini dimasukkan oleh pengguna melalui input menggunakan cin.
2. Dan loop for ini digunakan untuk membaca m edge yang diberikan oleh pengguna.
Dalam setiap iterasi, nilai node awal dan node tujuan disimpan dalam variabel u dan v,
dan kemudian edge ditambahkan ke daftar adjacency adj[u] dan adj[v].
3. Setelah semua edge dibaca, program mencetak adjacency list dari graf. Loop for
digunakan untuk mengiterasi setiap node dari 1 hingga n. Di setiap iterasi, program
mencetak "Node <nomor_node>: " diikuti oleh semua node yang terhubung dengan node
tersebut.
4. Program akan mengembalikan nilai 0, menandakan bahwa program berakhir dengan
sukses.

Jadi , dengan menggunakan struktur data adjacency list ini , program dapat
merepresentasikan graf tak berarah dengan efisien, karena hanya menyimpan edge yang
benar-benar ada dalam graf.

Studi Kasus 9.2

Sebuah studi kasus sederhana tentang graph dapat berupa graf yangmerepresentasikan
jaringan teman. Misalkan ada 4 orang yang saling berteman satusama lain, yaitu A,B,C,
dan D.Jika A berteman dengan B dan C,B berteman denganC dan D, C berteman dengan
D, dan D tidak berteman dengan siapa pun, maka grafyang merepresentasikan jaringan
teman ini dapat digambarkan sebagai berikut:

A – B -- D

\ |

\ |

\ |

Dalam graf ini, setiap orang direpresentasikan sebagai simpul atau node,sedangkankoneksi
antara mereka direpresentasikan sebagai sisi atau edge. Jika A ingin mencarijalan
terpendek untuk bertemu dengan D melalui jaringan temannya, maka dapatmenggunakan
algoritma pencarian jarak terpendek pada graf tersebut, sepertialgoritma Dijkstra atau
Bellman-Ford.

Dibawah ini program penyelesaian studi kasus-9.2

#include <iostream>

#include <vector>

using namespace std;

// Definisi fungsi untuk mencetak semua simpul dan sisi pada graf

void printGraph(const vector<vector<pair<int, int > > > & graph) {

for (int i = 0; i < graph.size(); i++) {

cout << "Simpul " << i << " : ";

for (int j = 0; j < graph[i].size(); j++) {

cout <<"(" << graph[i][j].first << "," << graph[i][j].second << ")";

cout << endl;

int main() {

// Inisialisasi vektor graf

vector<vector<pair<int, int > > > graph(5);

// Memasukkan sisi pada graf

graph[0].push_back(make_pair(1, 10)); // sisi dari A ke B dengan jarak 10

graph[0].push_back(make_pair(2, 15)); // sisi dari A ke C dengan jarak 15

graph[1].push_back(make_pair(2, 35)); // sisi dari B ke C dengan jarak 35

graph[1].push_back(make_pair(3, 30)); // sisi dari B ke D dengan jarak 30

graph[1].push_back(make_pair(4, 25)); // sisi dari B ke E dengan jarak 25

graph[2].push_back(make_pair(3, 45)); // sisi dari C ke D dengan jarak 45

graph[2].push_back(make_pair(4, 50)); // sisi dari C ke E dengan jarak 50

graph[3].push_back(make_pair(4, 55)); // sisi dari D ke E dengan jarak 55

// Mencetak semua simpul dan sisi pada graf

printGraph(graph);

return 0;

}
Hasil runnya :

Analisis :
Program di atas adalah contoh program implementasi sederhana dari representasi graf
menggunakan adjacency list dengan vektor di dalam vektor. Program ini mencetak semua
simpul dan sisi yang ada dalam graf.

1. Fungsi bernama printGraph ini yang menerima parameter sebuah vektor dari vektor
pasangan angka integer (vector<vector<pair<int, int>>> graph). untuk mencetak semua
simpul dan sisi dalam graf.
2. Di setiap iterasi loop pertama, program mencetak "Simpul <nomor_simpul> : " diikuti
oleh semua pasangan angka dalam vektor graph[i]. Pasangan angka ini mewakili sisi dari
simpul i ke simpul-simpul lainnya dalam graf.
3. Dan program akan mencetak pasangan angka dengan format "(<simpul_tujuan>,
<jarak>)", di mana simpul_tujuan adalah simpul yang terhubung dengan simpul i dan
jarak adalah jarak antara simpul i dan simpul_tujuan.
4. Kemudian, sisi-sisi pada graf dimasukkan ke dalam vektor graph menggunakan fungsi
push_back(). Setiap sisi direpresentasikan oleh pasangan angka yang terdiri dari simpul
tujuan dan jarak antara dua simpul tersebut.
5. Setelah semua sisi dimasukkan, program memanggil fungsi printGraph() untuk mencetak
semua simpul dan sisi pada graf yang telah dibuat.
6. Program ini akan mengembalikan nilai 0, yang menandakan bahwa program berakhir
dengan sukses.

Jadi dengan menggunakan representasi adjacency list dengan vektor di dalam vektor,
program ini memungkinkan untuk merepresentasikan graf dengan lebih fleksibel dan efisien.
Studi Kasus 9.3

Buatkan code C++ dengan lengkap untuk studi kasus penggunaan algoritma Concorde
untuk menyelesaikan masalah TSP:Misalkan ada seorang kurir yang harus mengirimkan
paket ke 3 kota. Jarak antara kota-kota tersebut adalah sebagai berikut:

 Kota A ke B:10
 Kota A ke C:15
 Kota B ke C:20

Tugas kurir adalah menemukan rute terpendek yang melewati semua kota tersebut dan
kembali ke kota asal. Masalah ini bisa direpresentasikan dalam bentuk graf dengan 3
simpul yang mewakili kota-kota dan 3 sisi yang mewakili jarak antar kota.

Berikut adalah langkah-langkah penggunaan algoritma Concorde untuk menyelesaikan

masalah TSP pada studi kasus ini:

1. Menentukan koordinat dari setiap kota. Karena hanya ada 3 kota, kita bisa
menggunakan koordinat (0,0), (10,0), dan (0,15) untuk mewakili kota A, B, dan C
secara berurutan.
2. Menghitung jarak antara setiap pasang kota. Dalam hal ini, kita telah diberi jarak antara
setiappasang kota, yaitu 10 antara kota A dan B, 15 antara kota A dan C, dan 20 antara
kota B dan C. Oleh karena itu, kita tidak perlu melakukan perhitungan jarak lagi.
3. Membuat matriks jarak antara setiap pasang kota. Dalam kasus ini, matriks jarak akan
memiliki ukuran 3x3 dengan nilai jarak yang telah ditentukan sebelumnya.
4. Menjalankan algoritma Concorde pada matriks jarak untuk menemukan rute terpendek
yang melewati semua kota dan kembali ke kota asal.
5. Menghasilkan rute terpendek dan mencetak jarak totalnya.

Buatlah code program penyelesaian studi kasus-9.3

#include <iostream>

#include <vector>

#include <cmath>

#include "concorde.h"

const int NUM_CITIES = 3; // Jumlah kota

// Fungsi untuk menghitung jarak antara dua kota

double calculateDistance(double x1, double y1, double x2, double y2)

{

double dx = x2 - x1;

double dy = y2 - y1;

return sqrt(dx * dx + dy * dy);

int main()

vector<double> xCoords = {0, 10, 0}; // Koordinat X dari setiap kota

vector<double> yCoords = {0, 0, 15}; // Koordinat Y dari setiap kota

// Membuat matriks jarak antara setiap pasang kota

vector<vector<double>> distanceMatrix(NUM_CITIES,
vector<double>(NUM_CITIES));

for (int i = 0; i < NUM_CITIES; i++)

for (int j = 0; j < NUM_CITIES; j++)

if (i == j)

distanceMatrix[i][j] = 0.0;

else

distanceMatrix[i][j] = calculateDistance(xCoords[i], yCoords[i], xCoords[j],

yCoords[j]);

}
 }

// Menggunakan algoritma Concorde untuk menemukan rute terpendek

Concorde concorde;

vector<int> tour = concorde.solveTSP(distanceMatrix);

// Mencetak rute terpendek

cout << "Rute Terpendek: ";

for (int i = 0; i < NUM_CITIES; i++)

cout << tour[i] << " ";

cout << tour[0] << endl; // Kembali ke kota asal

// Menghitung jarak total dari rute terpendek

double totalDistance = 0.0;

for (int i = 0; i < NUM_CITIES; i++)

int city1 = tour[i];

int city2 = tour[(i + 1) % NUM_CITIES];

totalDistance += distanceMatrix[city1][city2];

// Mencetak jarak total

cout << "Jarak Total: " << totalDistance << endl;

return 0;

}
Hasil runnya :

Program ini tidak bisa di run karena program tersebut harus didukung oleh software untuk
menjalankan Concorde.

Analisis :

Program diatas adalah sebuah implementasi sederhana dari algoritma Concorde untuk
menyelesaikan masalah penyebaran salesman traveling (TSP) dengan 3 kota. Program ini
menggabungkan beberapa konsep seperti vektor, matriks, dan penggunaan objek untuk
menyelesaikan masalah TSP dengan menggunakan algoritma Concorde. Program ini akan
menghasilkan rute terpendek dan jarak totalnya berdasarkan koordinat kota yang diberikan.

Studi Kasus 9.4

Buatkan code C++ dengan lengkap untuk studi kasus penggunaan algoritma Lin-Kernighan
untuk menyelesaikan masalah TSP: Misalkan ada seorang kurir yang harus mengirimkan
paket ke 3 kota. Jarak antara kota-kota tersebut adalah sebagai berikut:

 Kota A ke B:10
 Kota A ke C:15
 Kota B ke C:20

Tugas kurir adalah menemukan rute terpendek yang melewati semua kota tersebut dan
kembali ke kota asal. Masalah ini bisa direpresentasikan dalam bentuk graf dengan 3
simpul yang mewakili kota-kota dan 3 sisi yang mewakili jarak antar kota.

Berikut adalah langkah-langkah untuk menyelesaikan masalah TSP dengan menggunakan

algoritma Lin-Kernighan : Mulai dengan menginisialisasi sebuah solusi awal, misalnya
dengan mengunjungi kota-kota dalam urutan yang diberikan (A-B-C).

1. Hitung panjang rute dari solusi awal yang diperoleh.

2. Pertahankan solusi awal dan sebut solusi ini sebagai solusi terbaik.
3. Untuk setiap pasangan simpul (A, B) dalam rute, lakukan langkah-langkah berikut:
4. Ambil simpul A dan simpul B, lalu lepaskan simpul B dari rute.
5. Cari simpul X yang jaraknya paling dekat dengan simpul A (selain simpul B), yang
belum ada di dalam rute.
6. Cari simpul Y yang jaraknya paling dekat dengan simpul B (selain simpul A),yang
belum ada di dalam rute.
7. Coba gabungkan simpul A dan simpul Y, dan simpul X dan simpul B,lalu hitung
panjang rute baru.Jika panjang rute baru lebih pendek dari solusi terbaik yang ada,
simpan solusi ini sebagai solusi terbaik yang baru.
8. Ulangi proses ini dengan menggunakan simpul A dan simpul X, kemudian simpul Y
 dan simpul B.Jika ada rute yang lebih pendek yang ditemukan, simpan sebagai solusi
terbaik yang baru.
9. Ulangi langkah 4 dengan pasangan simpul yang lain dalam rute.
10. Ulangi langkah 2-5 hingga tidak ada perubahan yang signifikan dalam solusi terbaik
yang diperoleh.
11. Kembalikan solusi terbaik yang ditemukan.

Catatan:Algoritma Lin-Kernighan adalah algoritma iteratif, dan dapat menghasilkansolusi

yang lebih akurat dengan melakukan lebih banyak iterasi. Namun, semakin banyak iterasi
yang dilakukan, semakin lambat pula waktu eksekusi algoritma tersebut.

Buatlah code program penyelesaian studi kasus-9.4

#include <iostream>

#include <vector>

#include <cmath>

#include <limits>

using namespace std;

// Definisi konstanta untuk jumlah kota dan jarak antara kota

const int NUM_CITIES = 3;

const int distances[NUM_CITIES][NUM_CITIES] = {

{0, 10, 15},

{10, 0, 20},

{15, 20, 0}

};

// Fungsi untuk menghitung panjang rute

int calculateRouteLength(const vector<int>& route) {

int length = 0;

for (int i = 0; i < NUM_CITIES; i++) {

int currentCity = route[i];

 int nextCity = route[(i + 1) % NUM_CITIES];

length += distances[currentCity][nextCity];

return length;

// Fungsi untuk mencari rute terpendek menggunakan algoritma Lin-Kernighan

vector<int> solveTSP() {

vector<int> bestRoute;

vector<int> currentRoute;

for (int i = 0; i < NUM_CITIES; i++) {

currentRoute.push_back(i);

bestRoute.push_back(i);

int bestLength = calculateRouteLength(bestRoute);

bool improved = true;

while (improved) {

improved = false;

for (int i = 0; i < NUM_CITIES; i++) {

for (int j = i + 1; j < NUM_CITIES; j++) {

int cityA1 = currentRoute[i];

int cityA2 = currentRoute[(i + 1) % NUM_CITIES];

int cityB1 = currentRoute[j];

int cityB2 = currentRoute[(j + 1) % NUM_CITIES];

int originalLength = distances[cityA1][cityA2] + distances[cityB1][cityB2];

int newLength = distances[cityA1][cityB1] + distances[cityA2][cityB2];

if (newLength < originalLength) {

 vector<int> newRoute;

for (int k = 0; k <= i; k++) {

newRoute.push_back(currentRoute[k]);

for (int k = j; k > i; k--) {

newRoute.push_back(currentRoute[k]);

for (int k = j + 1; k < NUM_CITIES; k++) {

newRoute.push_back(currentRoute[k]);

currentRoute = newRoute;

int currentLength = calculateRouteLength(currentRoute);

if (currentLength < bestLength) {

bestRoute = currentRoute;

bestLength = currentLength;

improved = true;

return bestRoute;

int main() {

vector<int> bestRoute = solveTSP();

cout << "Rute terpendek: ";

 for (int i = 0; i < NUM_CITIES; i++) {

cout << bestRoute[i] << " ";

cout << bestRoute[0] << endl;

cout << "Panjang rute terpendek: " << calculateRouteLength(bestRoute) << endl;

return 0;

Hasil runnya :

Analisis :

Program ini adalah implementasi algoritma Lin-Kernighan untuk menyelesaikan masalah

Perjalanan Salesman (Traveling Salesman Problem / TSP) pada sebuah graf lengkap dengan
tiga kota. Berikut adalah analisis program tersebut:

Program ini memiliki 2 fungsi yaitu :

1) Fungsi calculateRouteLength
Digunakan untuk menghitung panjang rute berdasarkan urutan kota yang diberikan
sebagai argumen route. Fungsi ini menjumlahkan jarak antara setiap pasangan kota dalam
rute.

2) Fungsi solveTSP
Adalah inti dari program. Fungsi ini mengimplementasikan algoritma Lin-Kernighan
untuk mencari rute terpendek. Algoritma ini menggunakan pendekatan penukaran kota
 untuk meningkatkan rute secara iteratif. Fungsi ini mengembalikan vektor bestRoute yang
berisi rute terpendek yang ditemukan.

Program ini secara keseluruhan bekerja dengan menghitung rute terpendek yang melalui
setiap kota dan kembali ke kota awal. Algoritma Lin-Kernighan digunakan untuk mencari
pembaruan rute yang lebih baik dengan menukar kota-kota dalam rute. Program ini
menghasilkan rute terpendek dan panjang rute terpendek untuk tiga kota yang diberikan
dalam matriks distances.

Post Test

1. Code C++ Misalkan terdapat 3 simpul (A, B, C) yang terhubung dengan sisi berbobot
sebagai berikut:
 A ke B, jarak 5
 A ke C, jarak 2
 B ke C, jarak 3
 B ke A, jarak 8
Tujuan kita adalah mencari jalur terpendek dari simpul A ke simpul C. Dengan
menerapkan algoritma Djikstra.
Jawab :
Program

#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

// Fungsi untuk mencari jalur terpendek dari simpul s ke simpul t pada graf dengan
matriks ketetanggaan adjMatrix
vector<int> dijkstra(vector<vector<int > > & adjMatrix, int s, int t) {
int numNodes = adjMatrix.size();

// Inisialisasi jarak dari simpul s ke setiap simpul lainnya dengan nilai tak hingga
vector<int> dist(numNodes, INT_MAX);

// Inisialisasi simpul s dengan jarak 0

dist[s] = 0;

// Inisialisasi priority queue untuk menyimpan simpul yang belum dikunjungi

priority_queue<pair<int, int>, vector<pair<int, int > >, greater<pair<int, int > > >
pq;
 pq.push(make_pair(0, s));

// Loop sampai semua simpul dikunjungi

while (!pq.empty()) {
int u = pq.top().second;
pq.pop();

// Loop untuk semua simpul yang terhubung dengan simpul u

for (int v = 0; v < numNodes; v++) {
if (adjMatrix[u][v] != 0) {
int newDist = dist[u] + adjMatrix[u][v];
if (newDist < dist[v]) {
dist[v] = newDist;
pq.push(make_pair(newDist, v));
}
}
}
}

// Membuat vektor yang berisi jalur terpendek dari simpul s ke simpul t

vector<int> path;
int current = t;
while (current != s) {
path.insert(path.begin(), current);
for (int i = 0; i < numNodes; i++) {
if (adjMatrix[i][current] != 0 && dist[current] == dist[i] + adjMatrix[i]
[current]) {
current = i;
break;
}
}
}
path.insert(path.begin(), s);

return path;
}

int main() {
int numNodes = 3;

// Membuat matriks ketetanggaan untuk graf dengan 3 simpul (A, B, C) yang

terhubung dengan sisi berbobot
vector<vector<int > > adjMatrix(numNodes, vector<int>(numNodes, 0));
 adjMatrix[0][1] = 5;
adjMatrix[0][2] = 2;
adjMatrix[1][0] = 8;
adjMatrix[1][2] = 3;

// Mencari jalur terpendek dari simpul A ke simpul C

vector<int> shortestPath = dijkstra(adjMatrix, 0, 2);

// Mencetak jalur terpendek dan jarak totalnya

cout << "Jalur terpendek dari simpul A ke simpul C: ";
for (int i = 0; i < shortestPath.size(); i++) {
cout << (char)('A' + shortestPath[i]) << " ";
}
cout << endl;
int totalDistance = 0;
for (int i = 0; i < shortestPath.size() - 1; i++) {
totalDistance += adjMatrix[shortestPath[i]][shortestPath[i + 1]];
}
cout << "Jarak total: " << totalDistance << endl;

return 0;
}

Hasil runnya :

Analisis :
Program di atas adalah contoh implementasi algoritma Dijkstra untuk mencari jalur
terpendek antara dua simpul dalam graf berbobot. Program ini menggunakan matriks
ketetanggaan sebagai representasi graf.
1) Program dimulai dengan mendeklarasikan dan mengimpor header file iostream,
vector, queue, dan climits.
2) Kemudian, didefinisikan fungsi dijkstra yang menerima parameter sebuah matriks
ketetanggaan adjMatrix, dan dua simpul s dan t. Untuk mencari jalur terpendek dari
simpul s ke simpul t dalam graf.
3) Fungsi Dijkstra ini diinisialisasi variabel numNodes dengan ukuran matriks
ketetanggaan adjMatrix.
4) Kemudian, diinisialisasi vektor dist dengan nilai tak hingga (INT_MAX) untuk
menyimpan jarak dari simpul s ke setiap simpul lainnya.
5) Diinisialisasi priority queue (pq) untuk menyimpan simpul yang belum dikunjungi.
Simpul s dimasukkan ke dalam pq dengan jarak 0. Dan dilakukan loop sampai semua
simpul dikunjungi. Di setiap iterasi, simpul dengan jarak terkecil (u) diambil dari pq.
6) Untuk semua simpul yang terhubung dengan simpul u. Jika ada simpul yang
terhubung (v) dan memiliki jarak yang lebih kecil melalui u, maka jarak dist[v]
diupdate dan simpul v dimasukkan ke dalam pq.
7) Setelah semua simpul dikunjungi, dibuat vektor path untuk menyimpan jalur
terpendek dari simpul s ke simpul t. Simpul t diinisialisasi sebagai simpul terakhir
dalam jalur.
8) Dilakukan loop sampai mencapai simpul s. Di setiap iterasi, simpul sebelumnya (i)
yang terhubung dengan simpul saat ini (current) dan memiliki jarak yang sesuai
dijadikan simpul saat ini.
9) Program utama dimulai dengan mendeklarasikan variabel numNodes dengan nilai 3.
Membuat matriks ketetanggaan adjMatrix dengan ukuran 3x3 dan memasukkan bobot
sisi antara simpul-simpul yang terhubung.
10) Dan memanggil fungsi dijkstra untuk mencari jalur terpendek dari simpul A (0) ke
simpul C (2).
11) Setelah itu mencetak jalur terpendek dan jarak totalnya dengan mengiterasi vektor
shortestPath.
12) Program mengembalikan nilai 0, menandakan bahwa program berakhir dengan
sukses.