Laporan UAS Algoritma & Pemrograman

Dynamic Programming
Three Basic Example, The Knapsack Problem, Warshall's and Floyd's Algortithms

OLEH:
I Made Bagus Surya Wirayuda (1805551141)

PROGRAM STUDI TEKNOLOGI INFORMASI

FAKULTAS TEKNIK UNIVERSITAS UDAYANA
2022
Dynamic Programming

Program Dinamis (dynamic programming): metode pemecahan masalah dengan cara menguraikan
solusi menjadi sekumpulan langkah (step) atau tahapan (stage) sedemikian sehingga solusi dari
persoalan dapat dipandang dari serangkaian keputusan yang saling berkaitan.

Tinjau graf di bawah ini. Kita ingin menemukan lintasan terpendek dari 1 ke 10.

Greedy: dari setiap simpul, ambil sisi dengan bobot terkecil ke simpul berikutnya Solusi greedy: 1 – 2
– 6 – 9 – 10 dengan cost = 2 + 4 + 3 + 4 = 13 → tidak optimal!

Prinsip Optimalitas

• Pada program dinamis, rangkaian keputusan yang optimal dibuat dengan menggunakan Prinsip
Optimalitas.

• Prinsip Optimalitas: jika solusi total optimal, maka bagian solusi sampai tahap ke-k juga optimal.

• Prinsip optimalitas berarti bahwa jika kita bekerja dari tahap k ke tahap k + 1, kita dapat
menggunakan hasil optimal dari tahap k tanpa harus kembali ke tahap awal. 6

• Ongkos pada tahap k +1 = (ongkos yang dihasilkan pada tahap k ) + (ongkos dari tahap k ke tahap k
+ 1, atau ck,k+1 )
Karakteristik Persoalan dengan Program Dinamis

1. Persoalan dapat dibagi menjadi beberapa tahap (stage), yang pada setiap tahap hanya diambil satu
keputusan.

2. Masing-masing tahap terdiri dari sejumlah status (state) yang berhubungan dengan tahap
tersebut. Secara umum, status merupakan bermacam kemungkinan masukan yang ada pada suatu
tahap.

Graf multitahap (multistage graph). Tiap simpul di dalam graf tersebut menyatakan status, sedangkan
V1 , V2 , … menyatakan tahap.

3. Hasil dari keputusan yang diambil pada setiap tahap ditransformasikan dari status yang
bersangkutan ke status berikutnya pada tahap berikutnya.

4. Ongkos (cost) pada suatu tahap meningkat secara teratur (steadily) dengan bertambahnya jumlah
tahapan.

5. Ongkos pada suatu tahap bergantung pada ongkos tahap-tahap yang sudah berjalan dan onkos
dari tahap tersebut ke tahap berikutnya.
6. Adanya hubungan rekursif yang mengidentifikasikan keputusan terbaik untuk setiap status pada
tahap k memberikan keputusan terbaik untuk setiap status pada tahap k + 1. 7. Prinsip optimalitas
berlaku pada persoalan tersebut.

Dua pendekatan PD Dua pendekatan yang digunakan dalam program dinamis: 1. Program dinamis
maju (forward atau up-down) → Perhitungan dilakukan dari tahap 1, 2, …, n – 1, n 2. Program
dinamis mundur (backward atau bottom-up) → Perhitungan dilakukan dari tahap n, n – 1, …, 2, 1.

Misalkan x1 , x2 , …, xn menyatakan peubah (variable) keputusan yang harus ditentukan masing-

masing untuk tahap 1, 2, …, n. Maka, 1. Program dinamis maju. Program dinamis bergerak mulai dari
tahap 1, terus maju ke tahap 2, 3, dan seterusnya sampai tahap n. Rangkaian peubah keputusan
adalah x1 , x2 , …, xn . 2. Program dinamis mundur. Program dinamis bergerak mulai dari tahap n,
terus mundur ke tahap n – 1, n – 2, dan seterusnya sampai tahap 1. Rangkaian peubah keputusan
adalah xn , xn-1 , …, x1

Langkah-langkah Pengembangan Algoritma Program Dinamis

1. Karakteristikkan struktur solusi optimal. - tahap, variable keputusan, status (state), dsb

2. Definisikan secara rekursif nilai solusi optimal. - hubungan nilai optimal suatu tahap dengan tahap
sebelumnya

3. Hitung nilai solusi optimal secara maju atau mundur. - menggunakan table

4. Rekonstruksi solusi optimal (opsional). - rekonstruksi solusi secara mundur

Persoalan 1: Lintasan Terpendek (Shortest Path)

• Tentukan lintasan terpendek dari simpul 1 ke simpul 10:

How to find the shortest path?

(a) Karakteristikkan struktur solusi optimal

• Misalkan x1 , x2 , x3 , x4 adalah simpul-simpul yang dikunjungi pada tahap k (k = 1, 2, 3, 4). Tahap 5

tidak ada karena x5=10

• Misalkan digunakan pendekatan program dinamis maju

• Maka rute yang dilalui adalah x1→x2→x3→x4 → x5=10 Pada persoalan ini,

• Tahap (k) adalah proses memilih simpul tujuan berikutnya (ada 4 tahap).

• Status (s) yang berhubungan dengan masing-masing tahap adalah simpulsimpul di dalam graf
multi-tahap.
Pemrograman dinamis adalah teknik untuk memecahkan masalah dengan tumpang tindih
submasalah. Biasanya, subproblem ini muncul dari kekambuhan yang berkaitan dengan yang
diberikan solusi masalah untuk solusi dari submasalah yang lebih kecil. Daripada memecahkan
tumpang tindih submasalah lagi dan lagi, pemrograman dinamis menyarankan pemecahan masing-
masing submasalah yang lebih kecil hanya sekali dan mencatat hasilnya dalam sebuah tabel dari
mana solusi untuk masalah asli kemudian dapat diperoleh.

Teknik ini dapat diilustrasikan dengan meninjau kembali angka Fibonacci yang dibahas di Bagian 2.5.
(Jika Anda belum membaca bagian itu, Anda akan dapat mengikuti pokoknya diskusi. Tapi itu adalah
topik yang indah, jadi jika Anda tergoda untuk membacanya itu, mengalahlah padanya.) Angka
Fibonacci adalah elemen dari deret

0, 1, 1, 2, 3, 5, 8, 13, 21, 34,...,

yang dapat didefinisikan dengan perulangan sederhana

F (n) = F (n − 1) + F (n − 2) untuk n > 1 (8.1)

dan dua kondisi awal

F(0) = 0, F(1) = 1. (8.2)

Jika kita mencoba menggunakan perulangan (8.1) secara langsung untuk menghitung angka
Fibonacci ke-n F (n), kita harus menghitung ulang nilai yang sama dari fungsi ini berkali-kali

(lihat Gambar 2.6 sebagai contoh). Perhatikan bahwa masalah komputasi F (n) adalah dinyatakan
dalam submasalah komputasi yang lebih kecil dan tumpang tindih F (n − 1) dan F (n − 2). Jadi kita
cukup mengisi elemen array satu dimensi dengan nilai n + 1 berturut-turut dari F (n) dengan
memulai, mengingat kondisi awal (8.2), dengan 0 dan 1 dan menggunakan persamaan (8.1) sebagai
aturan untuk menghasilkan yang lainnya elemen. Jelas, elemen terakhir dari array ini akan berisi F
(n). Satu putaran

Metode Dynamic Programming

- Memorization
Metode yang digunakan agar angka yang sudah dieksekusi tidak terulang lagi. Memorization
berbeda dengan memorization, memorization adalah mengingat, namun memorization
adalah mengecek apakah pernah terhitung atau tidak
Analogi Dynamic Programming

1+1+1+1 = 4

Jika saya menambahkan +1, maka saya hanya perlu melakukan proses 4+1, saya tidak perlu
melakukan proses +1 dari awal, karena saya sudah melakukan proses menghitung 1+1+1+1 di awal

Secara garis besar Dynamic Programming

- Mengetahui pola
- Men-“store” haril proses valuenya
- Apabila menemukan proses yang hasil valuenya sama pada store, maka hanya perlu
mereturn value yang telah tersimpan di “store”

Knapsack problem

Knapsack problem adalah diibaratkan sebuah tas ransel yang mempunyai kapasitas berat maksimal
yang akan dimasukan beberapa barang dengan berat dan nilai yang berbeda-beda, dan barang yang
akan dimasukan kedalam ransel harus dipilih agar mendapatkan nilai atau value untuk
memaksimalkan keuntungan

Contoh kasus knapsack problem

Data berat dan nilai 5 jenis barang yang akan dimasukan dalam tas ransel dengan kapasitas 10kg

Jenis Barang Berat Value

1 4 kg 10
2 3 kg 15
3 3 kg 25
4 2 kg 20
5 1 kg 30

Pilihlah barang sesuai Batasan namun memaksimalkan total value barang

Berikut perhitungan untuk mendapatkan nilai value maksimal dari barang yang akan dimasukan
dalam ransel
Algorithm

Begin
Input set of items each with a weight and a value
Set knapsack capacity
Create a function that returns maximum of two integers.
Create a function which returns the maximum value that can be put in a knapsack of
capacity W
int knapSack(int W, int w[], int v[], int n)
int i, wt;
int K[n + 1][W + 1]
for i = 0 to n
for wt = 0 to W
if (i == 0 or wt == 0)
Do K[i][wt] = 0
else if (w[i - 1] <= wt)
Compute: K[i][wt] = max(v[i - 1] + K[i - 1][wt - w[i - 1]], K[i -1][wt])
else
K[i][wt] = K[i - 1][wt]
return K[n][W]
Call the function and print.
End

Source code :

#include <iostream>
using namespace std;
int max(int x, int y) {
return (x > y) ? x : y;
}
int knapSack(int W, int w[], int v[], int n) {
int i, wt;
int K[n + 1][W + 1];
for (i = 0; i <= n; i++) {
for (wt = 0; wt <= W; wt++) {
if (i == 0 || wt == 0)
K[i][wt] = 0;
else if (w[i - 1] <= wt)
K[i][wt] = max(v[i - 1] + K[i - 1][wt - w[i - 1]], K[i - 1][wt]);
else
K[i][wt] = K[i - 1][wt];
 }
}
return K[n][W];
}
int main() {
cout << "Masukan jumlah item di knapsack:";
int n, W;
cin >> n;
int v[n], w[n];
for (int i = 0; i < n; i++) {
cout << "Masukan value dan berat item " << i << ":";
cin >> v[i];
cin >> w[i];
}
cout << "Masukan kapasitas max knapsack";
cin >> W;
cout << knapSack(W, w, v, n);
return 0;
}

Hasil Output :
THREE BASIC EXAMPLE

Tujuan dari bagian ini adalah untuk memperkenalkan pemrograman dinamis melalui tiga tipikal

EXAMPLE 1

Masalah barisan koin Terdapat sebaris n koin yang nilainya beberapa bilangan bulat positif c1,
c2,...,cn, tidak harus berbeda. Tujuannya adalah untuk mengambil jumlah uang maksimum dengan
batasan bahwa tidak ada dua koin yang berdekatan di baris awal yang dapat diambil.

Biarkan F (n) menjadi jumlah maksimum yang dapat diambil dari deretan n koin. Untuk memperoleh
perulangan untuk F (n), kami mempartisi semua pilihan koin yang diizinkan menjadi dua kelompok:
yang termasuk koin terakhir dan yang tidak. Jumlah terbesar yang dapat kita peroleh dari kelompok
pertama sama dengan cn + F (n − 2)—nilai koin ke-n ditambah jumlah maksimum yang dapat kita
ambil dari n − 2 koin pertama. Jumlah maksimum yang bisa kita dapatkan dari kelompok kedua sama
dengan F (n − 1) oleh definisi F (n). Jadi, kita memiliki perulangan berikut yang tunduk pada yang
sudah jelas kondisi awal:

F (n) = maks{cn + F (n − 2), F (n − 1)} untuk n > 1,

F(0) = 0, F(1) = c1. (8.3)

Kita dapat menghitung F (n) dengan mengisi tabel satu baris dari kiri ke kanan dengan cara yang
mirip dengan cara yang dilakukan untuk bilangan Fibonacci ke-n oleh Algoritma Fib(n)

di Bagian 2.5

ALGORITMA CoinRow(C[1..n])

//Terapkan rumus (8.3) dari bawah ke atas untuk menemukan jumlah uang maksimum

// yang dapat diambil dari deretan koin tanpa mengambil dua koin yang berdekatan

//Input: Array C[1..n] bilangan bulat positif yang menunjukkan nilai koin

//Output: Jumlah maksimum uang yang dapat diambil

F[0]← 0; F[1]← C[1]

for i ← 2 to n do

F[i]← max(C[i] + F[i − 2], F[i − 1])

return F[n]

Penerapan algoritma pada deretan koin denominasi 5, 1, 2, 10,

6, 2 ditunjukkan pada Gambar 8.1. Ini menghasilkan jumlah maksimum 17. Perlu ditunjukkan
F[0] = 0, F[1] = c1 = 5

F[2] = max{1 + 0, 5} = 5

F[3] = max{2 + 5, 5} = 7

F[4] = max{10 + 5, 7} = 15

F[5] = max{6 + 7, 15} = 15

F[6] = max{2 + 15, 15} = 17

Memecahkan masalah baris koin dengan pemrograman dinamis untuk baris koin 5, 1, 2, 10, 6, 2.

bahwa, sebenarnya, kami juga memecahkan masalah untuk i koin pertama di baris yang diberikan
untuk setiap 1 ≤ i ≤ 6. Misalnya, untuk i = 3, jumlah maksimumnya adalah F (3) = 7. Untuk
menemukan koin dengan nilai total maksimum yang ditemukan, kita perlu menelusuri kembali
perhitungan untuk melihat yang mana dari dua kemungkinan—cn + F (n − 2) atau F (n − 1)—
menghasilkan maksimum dalam rumus (8.3). Pada aplikasi terakhir dari rumus tersebut adalah
penjumlahan c6 + F (4), yang berarti bahwa koin c6 = 2 merupakan bagian dari solusi optimal. Pindah
ke komputasi F (4), maksimum dihasilkan oleh penjumlahan c4 + F (2), yang berarti koin c4 = 10
adalah bagian dari solusi optimal juga. Akhirnya, maksimum dalam komputasi F (2) dihasilkan oleh F
(1), menyiratkan bahwa koin c2 bukan bagian dari solusi optimal dan koin c1 = 5 adalah. Jadi, solusi
optimalnya adalah {c1, c4, c6}. Untuk menghindari pengulangan perhitungan yang sama selama
penelusuran balik, informasi tentang mana dari dua suku di (8.3) yang lebih besar dapat direkam
dalam larik ekstra ketika nilai F dihitung.
Menggunakan CoinRow untuk menemukan F(n), jumlah uang terbesar yang dapat diambil, serta koin
yang menyusun set optimal, jelas membutuhkan (n) waktu dan (n) ruang. Ini jauh lebih unggul
daripada alternatifnya: aplikasi perulangan top-down langsung (8.3) dan menyelesaikan masalah
dengan pencarian lengkap

EXAMPLE 2

CONTOH 2 Masalah pembuatan perubahan Pertimbangkan contoh umum dari masalah terkenal
berikut. Berikan perubahan untuk jumlah n menggunakan jumlah minimum koin denominasi d1 < d2
< ... < dm. Untuk denominasi koin yang digunakan di Amerika Serikat, seperti yang digunakan di
sebagian besar jika tidak semua negara lain, ada algoritma yang sangat sederhana dan efisien yang
dibahas di bab berikutnya. Di sini, kami mempertimbangkan algoritme pemrograman dinamis untuk
kasus umum, dengan asumsi ketersediaan koin dalam jumlah tak terbatas untuk setiap denominasi
m d1 < d2 < ... < dm di mana d1 = 1.

Biarkan F (n) menjadi jumlah minimum koin yang nilainya berjumlah n; lebih mudah untuk
mendefinisikan F (0) = 0. Jumlah n hanya dapat diperoleh dengan menambahkan satu koin
denominasi dj ke jumlah n − dj untuk j = 1, 2,...,m sehingga n ≥ dj . Oleh karena itu, kita dapat
mempertimbangkan semua denominasi tersebut dan memilih salah satu yang meminimalkan F (n −
dj ) + 1. Karena 1 adalah konstanta, tentu saja kita dapat menemukan F (n − dj ) terkecil terlebih
dahulu dan kemudian menambahkan 1 ke dalamnya. . Oleh karena itu, kami memiliki perulangan
berikut untuk F (n):

Kita dapat menghitung F(n) dengan mengisi tabel satu baris dari kiri ke kanan dengan cara yang
serupa dengan cara yang dilakukan di atas untuk masalah baris koin, tetapi menghitung entri tabel di
sini memerlukan pencarian minimal hingga m angka .

ALGORITHM ChangeMaking(D[1..m], n)

// Menerapkan pemrograman dinamis untuk menemukan jumlah minimum koin

//dari denominasi d1 < d2 < ... < dm di mana d1 = 1 yang dijumlahkan dengan a

// diberikan jumlah n

//Masukan: Bilangan bulat positif n dan larik D[1..m] positif meningkat

// bilangan bulat yang menunjukkan denominasi koin di mana D[1] = 1

//Output: Jumlah minimum koin yang berjumlah n

F[0]← 0

for i ← 1 to n do

temp ← ∞; j ← 1
while j ≤ m and i ≥ D[j ] do

temp ← min(F[i − D[j ]], temp)

j←j+1

F[i]← temp + 1

return F[n]

Penerapan algoritma untuk jumlah n = 6 dan denominasi 1, 3, 4 ditunjukkan pada Gambar 8.2.
Jawaban yang dihasilkannya adalah dua koin. Efisiensi waktu dan ruang dari algoritme jelas masing-
masing adalah O(nm) dan (n).

F[0] = 0

F[1] = min{F[1 – 1]} + 1 = 1

F[2] = min{F[2 – 1]} + 1 = 2

F[3] = min{F[3 – 1], F[3 – 3]} + 1 = 1

F[4] = min{F[4 – 1], F[4 – 3], F[4 – 4]} + 1 = 1

F[5] = min{F[5 – 1], F[5 – 3], F[5 – 4]} + 1 = 2

F[6] = min{F[6 – 1], F[6 – 3], F[6 – 4]} + 1 = 2

EXAMPLE 3

Soal mengumpulkan koin Beberapa koin ditempatkan dalam sel papan n × m, tidak lebih dari satu
koin per sel. Robot, yang terletak di sel kiri atas papan, perlu mengumpulkan koin sebanyak mungkin
dan membawanya ke sel kanan bawah. Pada setiap langkah, robot dapat memindahkan satu sel ke
kanan atau satu sel ke bawah dari lokasinya saat ini. Saat robot mengunjungi sel dengan koin, ia
selalu mengambil koin itu. Rancang algoritme untuk menemukan jumlah maksimum koin yang dapat
dikumpulkan robot dan jalur yang harus diikuti untuk melakukannya.

Misalkan F (i, j ) adalah jumlah koin terbesar yang dapat dikumpulkan dan dibawa robot ke sel (i, j ) di
baris ke-i dan kolom ke-j dari papan. Itu dapat mencapai sel ini baik dari sel yang berdekatan (i − 1, j)
di atasnya atau dari sel yang berdekatan (i, j − 1) di sebelah kirinya. Jumlah koin terbesar yang dapat
dibawa ke sel ini adalah F (i − 1,j) dan F (i, j − 1). Tentu saja, tidak ada sel yang berdekatan di atas sel
di baris pertama, dan tidak ada sel yang berdekatan di sebelah kiri sel di kolom pertama. Untuk sel-
sel tersebut, kita asumsikan bahwa F (i − 1,j) dan F (i, j − 1) sama dengan 0 untuk tetangganya yang
tidak ada. Oleh karena itu, jumlah koin terbesar yang dapat dibawa robot ke sel (i, j ) adalah jumlah
maksimum dari kedua angka ini ditambah satu koin yang mungkin di sel (i, j ) itu sendiri. Dengan kata
lain, kami memiliki rumus berikut untuk F (i, j ):

F (i, j ) = max{F (i − 1, j ), F (i, j − 1)} + cij for 1 ≤ i ≤ n, 1 ≤ j ≤ m F (0, j) = 0 for 1 ≤ j ≤ m and F (i, 0) = 0 for
1 ≤ i ≤ n,

ALGORITHM RobotCoinCollection(C[1..n, 1..m])

//Applies dynamic programming to compute the largest number of

//coins a robot can collect on an n × m board by starting at (1, 1)

//and moving right and down from upper left to down right corner

//Input: Matrix C[1..n, 1..m] whose elements are equal to 1 and 0

//for cells with and without a coin, respectively

//Output: Largest number of coins the robot can bring to cell (n, m)

F[1, 1]← C[1, 1]; for j ← 2 to m do F[1, j ]← F[1, j − 1] + C[1, j ]

for i ← 2 to n do

F[i, 1]← F[i − 1, 1] + C[i, 1]

for j ← 2 to m do

F[i, j ]← max(F[i − 1, j ], F[i, j − 1]) + C[i, j ]

return F[n, m]

Algoritme diilustrasikan pada Gambar 8.3b untuk pengaturan koin pada Gambar 8.3a. Karena
menghitung nilai F (i, j ) dengan rumus (8.5) untuk setiap sel tabel membutuhkan waktu konstan,
efisiensi waktu dari algoritma adalah (nm). Efisiensi ruangnya, tentu saja, juga (nm). Menelusuri
perhitungan mundur memungkinkan untuk mendapatkan jalur yang optimal:
jika F (i − 1, j ) > F (i, j − 1), jalur optimal ke sel (i, j ) harus turun dari sel yang berdekatan di atasnya;
jika F (i − 1, j ) < F (i, j − 1), jalur optimal ke sel (i, j ) harus berasal dari sel yang berdekatan di sebelah
kiri; dan jika F (i − 1, j) = F (i, j − 1), ia dapat mencapai sel (i, j ) dari kedua arah. Ini menghasilkan dua
jalur optimal untuk contoh pada Gambar 8.3a, yang ditunjukkan pada Gambar 8.3c. Jika ikatan
diabaikan, satu jalur optimal dapat diperoleh dalam waktu (n + m).

FIGURE 8.3 (a) Coins to collect. (b) Dynamic programming algorithm results. (c) Two paths to collect 5
coins, the maximum number of coins possible.
Algoritma Floyd Warshall Algoritma

Floyd Warshall adalah salah satu algoritma dari pemrograman dinamis, yaitu suatu metode yang
melakukan pemecahan masalah dengan memandang solusi yang akan diperoleh sebagai suatu
keputusan yang saling terkait. Artinya solusi- solusi tersebut dibentuk dari solusi yang berasal dari
tahap sebelumnya dan ada kemungkinan lebih dari satu solusi. Algoritma Floyd Warshall juga
membandingkan semua kemungkinan lintasan pada graf untuk setiap sisi dari semua simpul.
Algoritma Floyd Warshall menerapkan pemrograman dinamis sehingga lebih menjamin keberhasilan
penemuan solusi optimum untuk kasus penemuan lintasan terpendek (single pair shortest path).
Penerapan algoritma Floyd-Warshall dilakukan berdasarkan hasil yang diperoleh dari tahap analisa
masalah. Algoritma Floyd-Warshall sangat efisien dari sudut pandang penyimpanan data karena
dapat diimplementasikan dengan hanya pengubahan sebuah matriks jarak [4]. Adapun mekanisme
dari algoritma FloydWarshall ini terdiri dari beberapa langkah yang harus dilakukan, yaitu :

a. Langkah awal yang harus dilakukan untuk menentukan shortest path dengan menggunakan
algoritma Floyd-Warshall adalah dengan merepresentasikan suatu graf sebagai suatu matriks
berbobot. Format output berupa matriks n x n berjarak D = [dij] dimana dij merupakan jarak dari
vertex i ke j.
b. Langkah kedua adalah melakukan dekomposisi Floyd-Warshall dengan urutan :

1. dij (k) merupakan panjang dari shortest path dari i ke j, sehinggasemua vertex intermediate
yang terdapat pada path (jika ada) terkumpul pada {1,2,....,k}
2. dij (0) dikumpulkan pada wij, yaitu tidak ada vertex intermediate.
3. D(k) menjadi matriks n x n [dij (k)] Tentukan dij (n) sebagai jarak dari i ke j kemudian hitung
D(n)
4. Hitung D(k) untuk k = 0,1,...., n
c. Langkah ketiga adalah menentukan struktur shortest path. Dalam hal ini, harus dilakukan dua
pengamatan terlebih dahulu sebelum melangkah lebih jauh, yaitu :
1. Sebuah shortest path tidak memuat vertex yang sama sebanyak dua kali
2. Untuk sebuah shortest path dari i ke j dengan beberapa vertex intermediate pada path dipilih
dari kumpulan {1, 2, ...., k}, dengan kemungkinan :

a. k bukan merupakan vertex pada path (path terpendek memiliki panjang dij (k1)).

b. k merupakan vertex pada path (path terpendek memiliki panjang dij(k-1) + dij(k-1)).

d. Setelah melakukan pengamatan diatas, kemudian dlakukan penentuan shortest path dari I k j
yang memuat vertex k :

1. Shorter path tersebut Memuat sebuah path dari k ke j

2. Setiap subpath hanya dapat memuat pertex intermediate pada (1,.., k-1.) dan sedapat
mungkin memiliki nilai terpendek kemudian beri nama panjangnya dik(k-1 dan dkj(k-1) sehingga
path memiliki panjang (dik(k-1) + dkj(k-1).

e. Langkah-langkah adalah melakukan iterasi yang dimulai dari iterasi ke 0 sampai dengan.
Perhitungan yang dilakukan adalah :
 1. Menentukan D(0) (iterasi ke 0) = [wij] merupakan matriks bobot.
2. Menentukan D(k) dengan menggunakan rumus, dij(k) = min {dij(k-1), dik(k-1) + dkj(k-1)},
untuk k = 1, ..., n dimana n adalah jumlah vertex.

Hasil akhir dari algoritma Floyd-Warshall adalah matriks untuk iterasi ke-n. Dari matriks ken ini, dapat
dilihat shortest path untuk setiap vertex padasuatu graph.

This C++ program displays the shortest path traversal from a particular node to
every other node present inside the graph relative to the former node.
Here is the source code of the C++ program of the Floyd Warshall Algoritm of finding
shortest paths from any node in graph to every other node with the shortest path
length displayed beside each pair of vertices. This C++ program is successfully
compiled and run on DevCpp, a C++ compiler. The program output is given below.

Source code:

1. /*
2. * C++ Program to Implement Floyd-Warshall Algorithm
3. */
4. #include <iostream>
5. #include <conio.h>
6. using namespace std;
7. void floyds(int b[][7])
8. {
9. int i, j, k;
10. for (k = 0; k < 7; k++)
11. {
12. for (i = 0; i < 7; i++)
13. {
14. for (j = 0; j < 7; j++)
15. {
16. if ((b[i][k] * b[k][j] != 0) && (i != j))
17. {
18. if ((b[i][k] + b[k][j] < b[i][j]) || (b[i][j] == 0))
19. {
20. b[i][j] = b[i][k] + b[k][j];
21. }
22. }
23. }
24. }
25. }
26. for (i = 0; i < 7; i++)
27. {
28. cout<<"\nMinimum Cost With Respect to Node:"<<i<<endl;
29. for (j = 0; j < 7; j++)
30. {
31. cout<<b[i][j]<<"\t";
32. }
33.
34. }
35. }
36. int main()
37. {
38. int b[7][7];
39. cout<<"ENTER VALUES OF ADJACENCY MATRIX\n\n";
40. for (int i = 0; i < 7; i++)
41. {
42. cout<<"enter values for "<<(i+1)<<" row"<<endl;
43. for (int j = 0; j < 7; j++)
44. {
45. cin>>b[i][j];
46. }
47. }
48. floyds(b);
49. getch();
50. }
Hasil Output :