Laporan Djikstra

LAPORAN TUGAS AKHIR
SISTEM CERDAS
PENENTUAN RUTE TERPENDEK PEMETAAN KRPAI PADA KARPET BIRU
MENGGUNAKAN METODE DIJKSTRA BERBASIS VISUAL C++
Disusun untuk Memenuhi Mata kuliah Sistem Cerdas

Yang Dibimbing oleh Ibu Anik Nur Handayani, S.T., M.T.
Oleh:
Kelompok 2
Hanis Bachrodin
120534431416
Hidayatul Kharomah
120534400678
Moh. Dhafir Arrosidi
120534400703
PTE D 2012
UNIVERSITAS NEGERI MALANG

FAKULTAS TEKNIK
PROGRAM STUDI PENDIDIKAN TEKNIK ELEKTRO
Desember 2014
BAB I
PENDAHULUAN
1.1 LATAR BELAKANG
Kontes Robot Pemadam Api Indonesia (KRPAI) 2015 yang mengusung tema
Kolaborasi Robot Pemadam Api di mana akan dipertandingkan 2 divisi, yaitu: 1)
Divisi Beroda, dan 2) Divisi Berkaki. Pada dasarnya, Tim robot yang memberikan
kontribusi terbanyak dalam memadamkan api akan menjadi pemenang. Oleh Karena itu
dalam kompetisi tersebut dibuat sebuah lapangan pertandingan dengan ukuran 486 cm x
244 cm. Desain lapangan tersebut terdiri dari gabungan dari dua lapangan pemadam api
type Trinity College yang berbentuk simetris (cermin) antara daerah Merah dan daerah
Biru. Lapangan terbuat dari papan multipleks dengan tebal 2 cm. Bentuk dan ukuran
Lapangan ditunjukkan pada Gambar 1. Di mana warna lantai untuk sisi merah maupun
biru sama, yaitu hitam. Pada beberapa tempat dilapisi karpet berwarna merah di sisi
merah dan biru di sisi biru yang lokasinya ditunjukkan pada Gambar 1. sedangkan
dinding berwarna putih.
Gambar 1. Bentuk dan Ukuran Lapangan

Pada lapangan tersebut setiap ruangan memiliki titik api. Dalam kompetisi ini
yang menjadi pemenang ialah tim robot yang memberikan kontribusi terbanyak untuk
memadamkan api dengan waktu tersingkat. Dengan demikian robot pemadam api
harus mampu mencapai titik api atau goal sehingga diperlukan metode dijkstra untuk
mencari goal.
1.2 RUMUSAN MASALAH
Berdasarkan latar belakang yang sudah dipaparkan, laporan tugas akhir ini
memiliki rumusan masalah yaitu Bagaimana menentukan rute terpendek yang harus
ditempuh robot agar sampai pada goal dengan waktu tersingkat menggunakan metode
dijkstra pada karpet biru?
1.3 TUJUAN
Berdasarkan rumusan masalah yang telah dipaparkan, laporan tugas akhir ini
memiliki tujuan Untuk menentukan rute terpendek dengan waktu tersingkat
menggunakan metode dijkstra pada karpet biru.
BAB II
LANDASAN TEORI
2.1 METODE ARTIFICIAL INTELIGENT

Dalam AI, terdapat metode-metode pencarian yang dibagi menjadi dua jenis,
yaitu:
1. Pencarian buta/tanpa informasi (Blind Un-informed Search)
2. Pencarian Heuristik/dengan informasi (Informed search)
Untuk mengukur performansi metode pencarian, terdapat empat kriteria yang

digunakan, yaitu:
1. Completeness, yaitu apakah metode tersebut menjamin penemuan solusi jika
solusinya memang ada?
2. Time complexity: Berapa lama waktu yang diperlukan?
3. Space complexity: Berapa banyak memori yang diperlukan?
4. Optimality : Apakah metode tersebut menjamin menemukan solusi yang terbaik
jika terdapat beberapa solusi berbeda?
2.2 METODE DIJKSTRA
Algoritma Dijkstra adalah salah satu metode untuk memecahkan masalah
pencarian rute terpendek. Algoritma ini biasanya diterapkan pada sebuah aplikasi pencari
rute jalan yang terdekat dari suatu daerah ke daerah lainnya. Untuk bisa menerapkan
algoritma ini dibutuhkan beberapa data yang harus disiapkan, yaitu :
1. Beberapa Titik/simpul/daerah, titik/simpul/daerah yang bisa dijangkau secara
langsung, dan juga jarak antara mereka.
2. Titik/simpul/daerah awal.
3. Titik/simpul/daerah tujuan.
Kelebihan algoritma dijkstra ialah dapat menyelesaikan beberapa kasus pencarian
lintasan terpendek, yaitu:
1. Pencarian lintasan terpendek antara dua buah simpul tertentu (a pair shortest
path)
2. Pencarian lintasan terpendek antara semua pasangan simpul (all pairs shortest
path)
3. Pencarian lintasan terpendek dari simpul tertentu ke semua simpul yang lain
(single-source shortest path)
4. Pencarian lintasan terpendek antara dua buah simpul yang melalui beberapa
simpul tertentu (intermediate shortest path.
Algoritma ini bertujuan untuk menemukan jalur terpendek berdasarkan bobot
terkecil dari satu titik ke titik lainnya. Misalkan titik mengambarkan gedung dan garis
menggambarkan jalan, maka algoritma Dijkstra melakukan kalkulasi terhadap semua
kemungkinan bobot terkecil dari setiap titik.
Gambar 1 Contoh keterhubungan antar titik dalam algoritma Dijkstra
Pertama-tama tentukan titik mana yang akan menjadi node awal, lalu beri bobot
jarak pada node pertama ke node terdekat satu per satu, Dijkstra akan melakukan
pengembangan pencarian dari satu titik ke titik lain dan ke titik selanjutnya tahap demi
tahap. Inilah urutan logika dari algoritma Dijkstra:
1.
Beri nilai bobot (jarak) untuk setiap titik ke titik lainnya, lalu set nilai 0 pada node
awal dan nilai tak hingga terhadap node lain (belum terisi)
2.
Set semua node Belum terjamah dan set node awal sebagai Node keberangkatan
3.
Dari node keberangkatan, pertimbangkan node tetangga yang belum terjamah dan
hitung jaraknya dari titik keberangkatan. Sebagai contoh, jika titik keberangkatan A
ke B memiliki bobot jarak 6 dan dari B ke node C berjarak 2, maka jarak ke C
melewati B menjadi 6+2=8. Jika jarak ini lebih kecil dari jarak sebelumnya (yang
telah terekam sebelumnya) hapus data lama, simpan ulang data jarak dengan jarak
yang baru.
4.
Saat kita selesai mempertimbangkan setiap jarak terhadap node tetangga, tandai
node yang telah terjamah sebagai Node terjamah. Node terjamah tidak akan
pernah di cek kembali, jarak yang disimpan adalah jarak terakhir dan yang paling
minimal bobotnya.
5.
Set Node belum terjamah dengan jarak terkecil (dari node keberangkatan) sebagai
Node Keberangkatan selanjutnya dan lanjutkan dengan kembali ke step 3.
BAB III
METODOLOGI
3.1 PERANCANGAN PROGRAM
Dalam hal ini hasil tugas akhir yang dibuat ialah berbentuk softfile program untuk
mempresentasikan algoritma dijkstra pada penentuan rute terpendek pemetaan KRPAI di
karpet biru sehingga perancangan yang dibutuhkan berupa:
1. Pemetaan KRPAI
2. Matriks:
a. Matriks koneksi
b. Matriks bobot
c. Matriks jarak
3. Compiler Visual C++
3.2 LANGKAH PEMBUATAN PERANCANGAN
1. Pemetaan KRPAI
Pemetaan KRPAI memiliki kandidat letak lilin yang ditunjukkan pada Gambar
2. posisi start berada di lorong.
Gambar 2. Kandidat posisi lilin

Langkah-langkah pembuatan pemetaan ialah sebagai berikut:
1. Menentukan posisi node yang menjadi letak lilin. Node tersebut berwarna orange.
2. Menetukan node yang menjadi node awal

Pada peta ini yang menjadi node awal ialah node 0 yang berwarna kuning
3. Menentukan node yang menjadi node goal

Pada pemetaan ini yang menjadi node goal ialah node yang menjadi letak lilin
yaitu node 4, node 5, node 8, node 9, node 12, node 15 ditambah lagi node 17
ditandai dengan node yang berwarna hijau. Hal ini dikarenakan penyelesaian
dijkstra yang dilakukan ialah per ruangan jika node di ruangan yang bersangkutan
sudah dilalui maka node tersebut akan menjadi node start untuk node goal
selanjutnya.
4. Membuat node bantuan

Node bantuan bertujuan untuk menghubungkan node start dengan node lain.
5.
Menentukan jarak node yang saling berhubungan
2. Matriks
Matriks yang dipakai ialah matriks 18x18
a. Matriks koneksi
Menyatakan koneksi node. Jika node tersebut berhubungan akan bernilai 1 dan
jika node tidak berhubungan atau node itu sendiri akan bernilai 0.
b. Matriks bobot
Menyatakan bobot dari tiap node yang berhubungan namun jika node yang
bersangkutan tidak berhubungan maka akan bernilai .
c. Matriks jarak
Menyatakan jarak yang harus ditempuh oleh sebuah node untuk sampai ke
node yang dituju atau node yang bersangkutan.
3. Compiler C++
Dengan menggunakan compiler C++ script program dijkstra ialah sebagai
berikut:
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
//file header untuk melibatkan obyek printf dan scanf
//pendeklarasian variabel bertipe int
int rumus,v,data_sebelumnya=99999,baris=99999;
int titik_dilewati[18],titik_awal,titik_akhir,iterasi=0;
//pendeklarasian array dari matriks
int koneksi[18][18]=
{
{0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
{1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
1,
{0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0},
1,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0},
0,
1,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
1,
0,
1,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
1,
0,
1,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
1,
0,
1,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
1,
0,
1,
{0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
1,
0,
{0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
1,
{0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1},
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0}
},
int bobot[18][18]=
{
{0,
72,
164,
0,
0,
0,
0,
0,
0,
0,
0,
0,
{72,
0,
0,
0,
0,
0,
46,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
0,
{164, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
141,
{0,
0,
46,
0,
0,
0,
0,
0,
87,
0,
0,
0},
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
{0,
0,
0,
87,
0,
46,
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
46,
0,
0,
0},
143,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
143,
0},
0,
118,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
118,
0,
97,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
97,
0,
24,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
24,
0,
97,
0,
{0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
97,
0,
92,
{0,
0,
0,
0,
141,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
92,
0,
{0,
103, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
103,
{0,
0,
0,
46,
0,
0,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
46,
0,
0,
0,
91,
0,
0,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
91,
0,
0,
0,
70,
0,
0,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
70,
0,
0,
0,
91,
0,
0},
0,
0,
0,
0,
0,
0,
{0,
0,
0,
0,
0,
0,
0,
91,
0,
0,
0,
118},
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
118,
0}
205,
251,
348,
466,
518,
494,
454,
545,
46, 133,
615,
179,
706,
322,
824},
440,
537,
561,
617,
369,
687,
415,
778,
558,
896},
451, 354,
330,
381,
87,
451,
660},
276,
394,
491,
942},
307,
404,
};
int jarak[18][18]=
{
{0
,
72 ,
{72
397,
305,
,
0 ,
164,
408,
236,
118,
469,
{164, 236,
377,
0,
480,
233,
{118, 46 ,
141,
282,
244,
0,
290,
515,
{205, 133,
515,
369,
423,
87,
526,
87,
572,
428,
{251, 179,
525,
415,
510,
613,
133, 46,
659,
479,
556,
{348, 322,
659,
558,
705,
796,
276, 189,
866,
143,
957,
0,
1075},
118,
336,
{466, 440,
428,
451,
531,
577,
394, 307,
668,
261,
738,
118,
829,
0,
947},
97,
218,
{518, 537,
310,
354,
413,
459,
491, 404,
550,
358,
620,
215,
711,
97,
829},
0,
24,
121,
213,
{494, 561,
316,
362,
453,
330, 515, 428,
523,
614,
382, 239,
732},
121,
24,
0,
429,
590,
708},
189,
292,
526,
282,
338,
542,
133,
663,
46,
733,
824,
189,
750,
820,
143,
0,
499,
911,
261,
1029},
358,
382,
215,
239,
121,
97,
{397, 469,
233,
515, 525,
479,
336,
218,
121,
97,
92,
195,
{305, 377,
141,
241,
332,
423, 510,
402,
556,
493,
428,
611},
310,
213,
189,
92,
0,
103,
{408, 480,
244,
149,
240,
526, 613,
310,
659,
401,
531,
528},
413,
316,
292,
195,
137,
577,
0,
103,
{454, 526,
0,
290,
46,
572, 659,
705,
207,
459,
298,
362,
416},
338,
241,
149,
{545, 617,
46,
381,
0,
91,
663, 750,
796,
161,
668,
550,
252,
453,
370},
429,
332,
240,
{615, 687,
137,
451,
91,
0,
70,
733, 820,
866,
738,
161,
523,
279},
499,
402,
310,
{706, 778,
207,
542,
161,
70,
824, 911,
957,
401,
{824, 896,
298,
660,
252,
942,
161,
1029,
91,
1075,
947,
118},
829,
732,
528,
416,
370,
279,
209,
118,
0}
0,
620,
91,
711,
829,
0,
209},
590,
614,
708,
493,
611,
};
// deklarasi fungsi main yang akan dieksekusi pertamakali
int main() {
printf("
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+\n");
printf("
+++++ Mencari Rute Terpendek dengan metode Djikstra ++++
+\n");
printf("
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+\n\n");
char pil;
cout<<endl;
cout<<"\t ============ MENU UTAMA ============ : \n";
cout<<endl;
cout<<"\t 1. Rute Bebas\n";
cout<<"\t 2. Rute Tertentu\n";
cout<<"\t 3. Rute Tertentu (Reverse) \n";
cout<<"\t 0. EXIT \n";
cout<<"\n";
cout<<"\tMasukkan Pilihan Anda : ";
cin>>pil;
cout<<"\n\n";
//Rute Bebas
if (pil == '1')
{
printf("===========================\n");
printf("Masukan node awal robot :");
scanf ("%d",&titik_awal);
printf("Masukan target robot:");
scanf ("%d",&titik_akhir);
printf("===========================\n");
while(baris!=titik_akhir)// ketika baris tidak sama dengan
titik_akhir
{
for(v=0;v<18;v++){
if(koneksi[titik_awal][v]==1){//jika titik awal dan titik
baris terkoneksi maka akan menjalankan rumus dibwahnya
rumus=bobot[titik_awal][v]+jarak[v][titik_akhir];//rumus = niali
bobot titik awal + nilai jarak baris titik akhir
if(data_sebelumnya>rumus){
data_sebelumnya=rumus;
baris=v;
titik_dilewati[iterasi]=baris;}
}
}
titik_awal=baris;
data_sebelumnya=99999;
iterasi++;
}
printf(" \n");
printf("----------------------------------------- \n");
printf("Jumlah titik yang dilewati
: %d titik\n",iterasi);
printf("Titik yang dilewati
:");
for(v=0;v<iterasi;v++){
printf("%d ",titik_dilewati[v]);
}
printf("\n-----------------------------------------");
printf("\n");
return 0;
}
//Rute tertentu
else
if (pil == '2')
{
char lanjutan;
titik_akhir=5;
titik_awal=0;
printf ("\n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf("++++ Karena Rute Ruang 3 harus dilewati ++++++ \n");
printf("++++
maka, Node 5 harus didahulukan
++++++ \n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf ("\n");
printf("============================\n");
printf("== Node awal robot
:0 == \n",titik_awal);
printf("== Target awal robot
:5 == \n",titik_akhir);
printf("============================\n");
titik_akhir
{
for(v=0;v<18;v++){
baris=v;
}
}
titik_awal=baris;
iterasi++;
}
printf(" \n");
printf("----------------------------------------- \n");

:");
}
printf("\n-----------------------------------------");
printf("\n");
cout << "\n Apakah anda ingin melanjutkan Rute Selanjutnya? [Y/N] : ";
cin >> lanjutan;
//Lanjutan
if (lanjutan == 'Y'||lanjutan=='y')
{
int titik_awal=5;
printf ("\n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf("++++Karena Rute dilanjutkan dariRuang 3 ++++++ \n");
printf("++++
maka, Node awal dari node 5
++++++ \n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf ("\n");
printf("============================\n");
printf(" Node awal robot
:5
\n",titik_awal);
printf(" Masukan Node target selanjutnya :
\n");
printf("============================\n");
titik_akhir
{
for(v=0;v<18;v++){
baris=v;
}
}
titik_awal=baris;
iterasi++;
}
printf(" \n");
printf("----------------------------------------- \n");
:");
}
printf("\n-----------------------------------------");
printf("\n");
}
else
return 0;
}
//rute tertentu
else
if (pil == '3')
{
char lanjutan;
int titik_akhir=8,titik_awal=17;
printf ("\n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf("++++ Karena Rute Ruang 4 harus dilewati ++++++ \n");
printf("++++
maka, Node 8 harus didahulukan
++++++ \n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf ("\n");
printf("============================\n");
printf("== Node awal robot
:17 == \n",titik_awal);
printf("== Target awal robot
: 8 == \n",titik_akhir);
printf("============================\n");
titik_akhir
{
for(v=0;v<18;v++){
baris=v;
}
}
titik_awal=baris;
iterasi++;
}
printf(" \n");
printf("----------------------------------------- \n");
:");
}
printf("\n-----------------------------------------");
printf("\n");
cout << "\n Apakah anda ingin melanjutkan Rute Selanjutnya? [Y/N] : ";
cin >> lanjutan;
//Lanjutan
if (lanjutan == 'Y'||lanjutan=='y')
{
int titik_awal=8;
printf ("\n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf("++++Karena Rute dilanjutkan dariRuang 4 ++++++ \n");
printf("++++
maka, Node awal dari node 8
++++++ \n");
printf("++++++++++++++++++++++++++++++++++++++++++++++ \n");
printf ("\n");
printf("============================\n");
printf(" Node awal robot
:8
\n",titik_awal);
printf(" Masukan Node target selanjutnya :
\n");
printf("============================\n");
titik_akhir
{
for(v=0;v<18;v++){
baris=v;
}
}
titik_awal=baris;
iterasi++;
}
printf(" \n");
printf("----------------------------------------- \n");
:");
}
printf("\n-----------------------------------------");
printf("\n");
}
else
return 0;
}
else
if (pil == '0')
{
cout<<" TERIMA KASIH " <<endl;
getch();
return 0;
}
else if (pil != '1' || pil!='2' || pil!='3' || pil!='4' || pil !=
'x')
{
cout<<endl;o
cout<<"Pastikan yang anda Input bener Guys!!! "<<endl;
}
getch();
}
3.3 FLOWCHART
BAB IV
PEMBAHASAN
4.1 ANALISA DATA
Gambar 3. Pemetaan KRPAI

Start node 0
Goal: Room 3 node 4 (terlampir)
4.2 HASIL PROGRAM
1.
2. Menu Kedua
Tampilan Menu Utama
BAB V
PENUTUP
5.1 KESIMPULAN
Pada tugas akhir yang telah dibuat dapat diambil kesimpulan sebagai berikut:
1.
Program metode dijkstra yang telah dibuat memiliki 4 menu utama

yaitu:
1. Rute Bebas
2. Rute Tertentu
3. Rute Tertentu (Reverse)
4. Exit
2. Metode dijkstra digunakan untuk menentukan rute terpendek dari pemetaan KRPAI
dimulai dari node start yaitu node 0 hingga goal node yaitu node 4, node 5, node 8,
node 9, node 12, node 15 dan node 17. Di mana penyelesaian dijkstra dilakukan
dengan menyelesaikan goal node per ruangan, jika node di ruangan yang
bersangkutan sudah dilalui maka node tersebut akan menjadi node start untuk goal
node selanjutnya.
3. Dalam hal ini program dijkstra dan perhitungannya sudah sesuai seperti yang
diharapkan.
5.2 SARAN
Untuk pengembangan tugas akhir yang telah dibuat, penulis memberi saran
sebagai berikut:
1. Dalam pengimplementasian penentuan rute terpendek menggunakan dijkstra perlu
diperhatikan pembuatan rutenya. Di mana dalam pembuatan rute ditentukan mana
yang menjadi node awal dan node akhir.
2. Untuk mengimplementasikan program metode dijkstra disarankan agar memperbaiki
kelemahan algoritma yang ada.
3. Pada program penentuan rute terpendek sebaiknya diberi pemetaan rute agar lebih
pmudah dipahami bagi pembaca.
DAFTAR RUJUKAN
Arjuna. 2011. Pengertian Artificial Intelligence (kecerdasan buatan), (Online)

(https://buahilmu.wordpress.com/2011/04/13/pengertian-artificial-intelligencekecerdasan-buatan/) diakses 8 Desember 2014
Kadir, Abdul.2003. C++ Membahas Pemrograman Berorientasi Obje Menggunakan Turbo
C++ dan Borland C++.Yogyakarta:ANDI.

Laporan Djikstra

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Laporan Djikstra

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN TUGAS AKHIR

Disusun untuk Memenuhi Mata kuliah Sistem Cerdas

Moh. Dhafir Arrosidi

UNIVERSITAS NEGERI MALANG

Gambar 1. Bentuk dan Ukuran Lapangan

2.1 METODE ARTIFICIAL INTELIGENT

Untuk mengukur performansi metode pencarian, terdapat empat kriteria yang

Gambar 1 Contoh keterhubungan antar titik dalam algoritma Dijkstra

Gambar 2. Kandidat posisi lilin

2. Menetukan node yang menjadi node awal

3. Menentukan node yang menjadi node goal

4. Membuat node bantuan

Menentukan jarak node yang saling berhubungan

+++++ Mencari Rute Terpendek dengan metode Djikstra ++++

printf("Jumlah titik yang dilewati

Gambar 3. Pemetaan KRPAI

Tampilan Menu Utama

Program metode dijkstra yang telah dibuat memiliki 4 menu utama

Arjuna. 2011. Pengertian Artificial Intelligence (kecerdasan buatan), (Online)

Anda mungkin juga menyukai