ANALISA SEARCHING ALGORITHM
BREADTH-FIRST, DEPTH-FIRST
DAN BEST-FIRST SEARCH PADA
PENYELESAIAN PROBLEM KOTAK-8
DESI RAMAYANTI (23206006)
ARWIN (23206008)
HENDRA (23206017)
Permasalahan problem solving yang dihadapi di
p
g y
g
p
dunia nyata dapat dilakukan melalui pendekatan
secara intelligence atau “cerdas”. Paradigma yang
digunakan :
{
Artificial Intelligence
{
Computational Intelligence (Artificial Neural Networks
-ANN)
{
Fuzzy Logic
y
g
{
Evolutionary Computation
Dalam konteks permasalahan problem solving,
paradigma yang banyak digunakan adalah Artificial
Intelligence (AI) atau Kecerdasan Tiruan
AI mempunyai beberapa metode untuk
e pu ya bebe apa
etode u tu
menyelesaikannya. Salah satu dari metode
tersebut adalah Metode Searching
Hal yang sangat menarik adalah bagaimana
searching algorithm yang diterapkan berusaha
mencari solusi, yang diistilahkan dengan goal
state (GS) paling optimal dan lengkap dengan
state (GS), paling optimal dan lengkap dengan
berbagai kompleksitas waktu dan ruang yang
dihadapinya dari kondisi awal atau initial state
(IS) yang diberikan.
Paradigma AI banyak digunakan dalam berbagai aplikasi
dan salah satu diantaranya adalah game, diantaranya
aplikasi 8 p
le ata Kotak 8
aplikasi 8-puzzle atau Kotak-8
Karakteristik menarik dari game ini adalah pada
representasi data yang akan diolah oleh searching
algorithm yang diaplikasikan kepadanya.
Untuk mengetahui lebih detil, di dalam naskah akan
disampaikan analisa pembangkitan generasi penerus
(successor) simpul induk (parent) hingga didapatkan
(successor) simpul induk (parent) hingga didapatkan
anak (node) terbaik ditinjau dari mekanisme searching
algorithm
{
Breadth-First Search (BFS)
{
Depth-First Search (DFS)
Naskah ini disusun dengan tata urut
Naskah ini disusun dengan tata urut
{
Bagian I berisi latar belakang penulisan naskah
{
Bagian II akan disampaikan konsep AI dan searching
algorithm yang akan dipresentasikan
{
Bagian III implementasi software searching algorithm
yang digunakan untuk problem solving Kotak-8.
{
Bagian IV akan disampaikan analisa problem solving
{
Bagian IV akan disampaikan analisa problem solving
pada Kotak-8
{
Bagian V kesimpulan hasil analisa dari aplikasi
searching algorithm pada permasalahan Kotak-8 ini.
AI adalah suatu disiplin ilmu yang mempelajari bagaimana atau untuk membuat
komputer agar mampu mendekati kecerdasan sebagaimana makhluk hidup
Wikipedia mendefinisikan AI sebagai a branch of computer science that deals
with intelligent behavior, learning and adaptation in machines.
Di dalam penyelesaian suatu permasalahan, AI dianggap sebagai suatu Sistem
Produksi yang berlandaskan pada 3 (tiga) komponen yakni :
{
Fakta
Æ menyatakan deskripsi tentang obyek yang menjadi perhatian
{
Kaidah (rule)
Æ aturan yang bila diterapkan pada suatu keadaan (state)
(dari fakta) akan menghasilkan keadaan (state) baru
Prakondisi (antecedent)
Æ persyaratan agar suatu kaidah tertentu
dapat diterapkan pada suatu state
Aksi (consequence)
Æ hasil yang diperoleh bila kaidah yang
bersangkutan dieksekusi.
{
Inferensi (penalaran)
Æ adalah untaian (chain) dari kaidah untuk bergerak
dari keadaan awal (initial state) menuju keadaan sasaran (goal state)
Karakteristik menarik AI dalam menyelesaikan suatu masalah adalah
adanya karakteristik heuristik yang melekat padanya.
Heuristik adalah
{
Prinsip atau informasi atau knowledge (bersifat problem-specific)
yang dapat digunakan sebagai panduan (guidance) dalam
penelusuran untuk mencapai goal states dengan cara yang efektif.
{
Estimasi seberapa dekat current state dengan goal state dan ia yang
membedakan penelusuran yang bersifat “intelligence” dengan yang
tidak. Ia tidak unik dan merupakan gabungan dari beberapa prinsip
atau informasi namun tidak menjamin (secara penuh) dicapainya goal
states.
{
Salah satu metode dari informed search
{
Dapat dianggap sebagai pruning (memotong pohon) dengan
mempertimbangkan node yang promising (menjanjikan atau lebih
pasti menuju GS).
Oleh karena itu, seyogyanya fungsi heuristik tidak terlalu rumit (sederhana
dan mudah untuk dihitung) karena akan diaplikasikan ke setiap node.
Dalam proses pencarian solusi terbaik, AI melakukan tindakan
penelusuran (searching) menggunakan suatu algoritma tertentu.
Searching pada dasarnya adalah penelusuran untuk mendapatkan
l
k h t
d k t ( i i
l)
j GS d
i IS d
k
langkah terdekat (minimal) menuju GS dari IS dengan menggunakan
kaidah (rule). Arah searching ditujukan kepada jumlah GS terbesar.
Searching ditentukan oleh 3 (tiga) faktor :
{
branching factor yang menyatakan jumlah rata-rata simpul yang
dapat dicapai oleh simpul induk secara langsung, jumlah rata-rata
kaidah untuk mencapai state berikutnya dan seberapa luas state
space tree diagram searching
{Jumlah GS
{
Model penalaran manusia.
Searching dapat dilakukan melalui salah satu dari 2 (dua) arah
{forward searching yang mengikuti model penalaran manusia dan
backward searching. Metode forward searching dilakukan dengan
mencocokkanya dengan Prakondisi dan dilakukan bila branching
factor kecil
{
backward searching dilakukan dengan cara mencocokkannya
Proses penelusuran adalah sebagai berikut :
Proses penelusuran adalah sebagai berikut :
{
Diberikan keadaan awal atau IS.
{
Aplikasikan prosedur atau kaidah dengan persyaratan
Prakondisi dan Aksi yang telah ditetapkan untuk
mendapatkan GS.
{
Terapkan control strategy dengan memilih satu dari
active rule yang ada untuk diterapkan. Control
y
g
p
strategy akan menentukan kesuksesan proses
penelusuran. Kesalahan pemilihan control strategy
akan berdampak pada tidak didapatkannya solusi
seperti yang diharapkan.
Konsep dasar
Æ penelusuran dengan cara mengekplorasi simpul
k
t
k li i b k
Bil GS tid k dit
k
d
anak yang pertama kali ia buka. Bila GS tidak ditemukan pada
simpul yang dibuka, ia akan bergerak mundur untuk membuka
simpul anak berikutnya
{
Berikan simpul awal pada daftar “open”.
{
Loop : if open = kosong then exit(fail).
{
n := first(open)
{
if goal(n) then exit(success)
{
Remove(n, open) dan Add(n, closed)
{
Ekspansikan n. Berikan pada kepala “open” semua simpul
anak yang belum muncul pada “open” atau “closed” dan
bubuhkan pointer pada n.
{
Kembali ke Loop.
[ S ]
[ A B ]
S IS[ A B ]
[ C D B ]
[ D B ]
[ B ]
[ E F ]
[ H G F ]
[ G F ]
Urutan pelacakan :
S A B C D E F ISS, A, C, D, B, E, F, H, G
Fungsi pointer untuk solution
path
Tree Diagram
Urutan Searching
H G
Konsep dasar
Æ BFS akan melakukan penelusuran pada semua
cabang yang dibuka dari simpul induknya Pencarian dilakukan
cabang yang dibuka dari simpul induknya. Pencarian dilakukan
dalam arah horisontal sehingga semua cabang yang dibuka
dijamin akan mendapatkan giliran yang adil. Bila pada kedalaman
(depth) yang sama GS belum ditemukan, maka dilakukan
pembukaan cabang baru lagi sesuai dengan urutan pembukaan
cabang sebelumnya
{
Berikan simpul awal pada daftar “open”.
{
Loop : if open = kosong then exit(fail).
{
n := first(open)
( p
)
{
if goal(n) then exit(success)
{
Remove(n, open) dan Add(n, closed)
{
Ekspansikan n, berikan semua simpul anak pada ekor
“open” dan bubuhkan pointer dari simpul anak ke-n.
{
Kembali ke Loop.
[ S ]
[ A B ]
[ B C D ]
[ C D E F ]
[ D E F ]
[ E F ]
[ F H G ]
[ H G ]
[ G ]
Urutan pelacakan :
Urutan pelacakan :
S, A, B, C, D, E, F, H, G
Fungsi pointer untuk solution path
Tree Diagram
Urutan Searching
Konsep dasar
Æ metode BsFS menggunakan nilai nilai heuristik
tiap simpul yang dibuka Simpul dengan nilai heuristik terkecil
tiap simpul yang dibuka. Simpul dengan nilai heuristik terkecil
akan dibuka terlebih dulu. Bila GS belum ditemukan, akan
dilakukan pemeriksaan pada simpul berikutnya dengan nilai
heuristik terkecil pada kedalaman yang sama
{
Berikan simpul awal pada daftar “open”
{
Loop : if open = kosong then exit(fail).
{
n := first(open)
{
if goal(n) then exit(success)
{
if goal(n) then exit(success)
{
Remove(n, open) dan Add(n, closed)
{
Ekspansikan n, hitung h(n) untuk semua simpul anak ni
dan bubuhkan pointer dari ni ke-n. Berikan semua simpul
anak pada “open” dan urutkan mulai dari biaya
terendahnya.
{
Kembali ke Loop
Time Complexity yang menyatakan waktu yang
diperlukan untuk mencapai sasaran. Ini sangat
berkaitan erat dengan cp time dan branching factor
berkaitan erat dengan cpu time dan branching factor.
Space Complexity yang mengukur jumlah memory yang
dibutuhkan untuk implementasi search dan diukur
dalam bentuk besar byte.
Completeness yang mengukur jaminan bahwa GS
dicapai oleh search berdasarkan pada searching
algorithm yang dipakai
algorithm yang dipakai.
Optimality yang memberikan ukuran jaminan bahwa
solution path adalah paling minimum.
Shortest path to GS
(solution path)
Penekanan utama :
Penekanan utama :
{
Representasi struktur data.
{
Proses pembangkitan generasi
penerus (successor) atau simpul anak
(
)
(child node).
{
Solution path.
Compiler /Intepreter JDK versi 1.5.0.9 dengan
Compiler /Intepreter JDK versi 1.5.0.9 dengan
Editor JCreator LE versi 4.0
Representasi Data
Æ Struktur data
direpresentasikan dalam bentuk vektor matriks
dengan dimensi 1 x 9, sebagai contoh adalah [ 7
1 4 2 3 5 8 0 6 ] dimana “0” mewakili lokasi yang
tid k t
i i
d
til K t k 8
tidak terisi pada susunan tile Kotak-8
Implementasi BFS, DFS, BestFS dan Solution
MyPuzzle.class
MyShufflePuzzle.class
M T
S
h l
MyTreeSearch.class
State.class
-order : int[] -parent : State -size : int -level : int -cost : int -stateNum : int -path : String -pathBuffer : StringBuffer -heuristic : int+State(in initState : State, in order : int[]) +init() : void +getLevel() : int +getHeuristic() : int +getStateNum() : int +getCost() : int +getPath() : int +getParent() : State +setPath(in path : String) : void +setParent(in parent : State) : void +setLevel(in level : int) : void +calculateHeuristic(in goal : int[]) : void +isRoot() : boolean MyTreeSearch -initState : State -goalState : State -depth : int -numofState : int -open : LinkedList +isRoot() : boolean +getOrder() : int[]
+isGoal(in goalState : State) : boolean +moveUp() : State +moveDown() : State +moveRight() : State +moveLeft() : State +shuffle() : State +getSuccessors() : ArrayList -getZeroposition(in order : int[]) : int -copyOrder() : int[] -compareTo(in o : Object) : int -toString() : String
-close : ArrayList -goalFound : Boolean = false -printSolution : Boolean
+MyTreeSearch(in initState : State, in goalState : State, in depth : in, in printSolution : boolean) +depthFirstSearch() : void
+breadthFirstSearch() : void +bestFirstSearch() : void
+printSolutionPath(in theState : State) : void
n
1
Mo de P
akai
public void breadthFirstSearch() { State currentState = null;
open.addFirst(initState); Berikan simpul awal pada daftar “open”
System.out.println("Pencarian dengan Breadth First Search...");
while (!open.isEmpty()) { currentState = (State) open.getFirst();
System.out.println(currentState.toString() + "\n");
if ( currentState.isGoal(goalState)) { goalFound = true;
System out println("Goal ditemukan "); Loop : if open = kosong then exit(fail)
n := first(open) System.out.println("Goal ditemukan.."); if(printSolution) printSolutionPath(currentState); break; } open.removeFirst(); close.add(currentState.toString()); if goal(n) then exit(success)
Remove(n, open) Add(n, closed)
if (currentState.getLevel() < depth) { ArrayList list = currentState.getSuccessors();
Ekspansikan n. Berikan pada ekor “open” semua simpul anak yang belum muncul pada “open” atau “closed” dan bubuhkan pointer pada n.
Iterator e = list.iterator(); while (e.hasNext()) {
State successor = (State) e.next(); //untuk Solution Path
if(printSolution) successor.setParent(currentState); if (!close.contains(successor.toString())) { open.addLast(successor); numOfState++; } Kembali ke Loop } } } } if (!goalFound)
System.out.println("Goal tidak ditemukan..."); }
public void depthFirstSearch() { State currentState = null;
open.addFirst(initState);
S t t i tl ("P i d
Berikan simpul awal pada daftar “open”
System.out.println("Pencarian dengan Depth First Search...");
while (!open.isEmpty()) { currentState = (State) open.getFirst();
System.out.println(currentState.toString() + "\n");
if ( currentState.isGoal(goalState)) { System.out.println("Goal ditemukan..."); Loop : if open = kosong then exit(fail)
n := first(open) goalFound = true; if(printSolution) printSolutionPath(currentState); break; } open.removeFirst(); close.add(currentState.toString()); System.out.println(currentState.getLevel());
if goal(n) then exit(success)
Remove(n, open) Add(n, closed)
if (currentState.getLevel() < depth) { ArrayList list = currentState.getSuccessors();
System.out.println("Jumlah suksesor : " + list.size());
Iterator e = list.iterator(); while (e.hasNext()) {
State successor = (State) e.next(); //untuk Solution Path
if(printSolution)
successor.setParent(currentState); if (!close.contains(successor.toString())) { Ekspansikan n. Berikan pada kepala
“open” semua simpul anak yang belum muncul pada “open” atau “closed” dan bubuhkan pointer pada n.
( ( g())) { open.addFirst(successor); numOfState++; } } } } if (!goalFound)
System.out.println("Goal tidak ditemukan..."); }
Kembali ke Loop
public void bestFirstSearch() { State currentState = null; open = new LinkedList(); ArrayList close = new ArrayList(); ArrayList close = new ArrayList();
open.addFirst(initState);
System.out.println("Pencarian dengan Best First Search...");
while (!open.isEmpty()) { currentState = (State) open.getFirst(); System.out.println(currentState.toString() + " nilai
heuristik = " + currentState.getHeuristic() + "\n"); if ( currentState.isGoal(goalState)) {
goalFound = true; Berikan simpul awal pada daftar “open”
Loop : if open = kosong then exit(fail) n := first(open) goalFound = true; System.out.println("Goal ditemukan..."); if(printSolution) printSolutionPath(currentState); break; } open.removeFirst(); close.add(currentState.toString()); if goal(n) then exit(success)
Remove(n, open) Add(n, closed)
ArrayList list = currentState.getSuccessors(); Iterator e = list.iterator();
while (e.hasNext()) { Ekspansikan n, hitung h(n)
untuk semua simpul anak ni dan bubuhkan pointer dari ni
ke-n ( ()) {
State successor = (State) e.next();
//ditambahkan untuk menunjuk ke parent
if(printSolution)
successor.setParent(currentState);
if (!close.contains(successor.toString())) { successor.calculateHeuristic(goalState.getOr der()); // calculate heuristic
open.addFirst(successor);
numOfState++; }
ke n.
Berikan semua simpul anak pada “open” dan urutkan mulai dari biaya terendahnya.
} }
//sort open list in order of heuristic value Collections.sort(open);
}
if (!goalFound)
System.out.println("Goal tidak ditemukan"); }
Kembali ke Loop
public void printSolutionPath(State theState) { State curState = null;
Stack stack = new Stack();
System.out.println("Solution pathnya adalah .. \n\n");
//lakukan backtrack untuk menentukan solution pathnya... while(theState != null) { stack.push(theState); theState = theState.getParent(); } while(true) { try {
curState = (State)stack pop(); curState = (State)stack.pop(); } catch(EmptyStackException e) { break; } System.out.println(curState.toString() + "\n"); } }
Digunakan 4 (empat) vektor input untuk
Digunakan 4 (empat) vektor input untuk
membandingkan keefektifan algoritma dan
solution path paling efisien
{
[ 1 0 3 4 5 6 2 7 8 ]
{
[ 1 4 3 0 2 6 5 7 8 ]
[
]
{
[ 7 4 3 1 2 6 5 0 8 ]
{
[ 2 5 3 1 6 0 4 7 8 ]
Test Input
Vector Algoritma Depth Completeness Optimality
Panjang Solution Path (Cost) Simpul dibuka BFS Ya Ya 11 2.237 15 DFS Ya Tidak 21 7.425 BestFS Ya Tidak 47 205 BFS 20 Ya Ya 17 29.288 DFS Tidak Tidak GS tidak
ditemukan 5.431
BestFS Ya Ya 109 495
BFS Ya Ya 13 4.741
20
DFS Tidak Tidak GS tidak
ditemukan 2.220 BestFS Ya Tidak 91 996 BFS 25 Ya Ya 7 268 DFS Ya Tidak 25 3.830 BestFS Ya Ya 7 15
Test Input
Vector Algoritma Depth Completeness Optimality
Panjang Solution Path (Cost) Simpul dibuka BFS Ya Ya 11 2.237 15 DFS Ya Tidak 21 7.425 BestFS Ya Tidak 47 205 BFS 25 Ya Ya 17 29.288 DFS Ya Tidak 25 5.098 BestFS Ya Tidak 109 495 BFS Ya Ya 13 4.741 30 DFS Ya Tidak 29 15.670 BestFS Ya Tidak 91 996 BFS 25 Ya Ya 7 268 DFS Ya Tidak 25 3.830 BestFS Ya Ya 7 15 Depth - 0 1 3 0 1 5 3 0 1 3 4 5 6 2 7 8 Rule Ka Rule Ba Rule Ki 4 5 6 2 7 8 4 7 6 2 5 8 4 0 6 7 2 8 1 0 3 4 5 6 2 7 8 Rule Ba Pruning 1 3 6 4 5 0 2 7 8 Rule Ka Rule Ba 1 5 3 4 7 6 2 0 8 1 5 3 4 6 0 2 7 8 Rule Ki 1 5 3 0 4 6 2 7 8 1 0 3 4 5 6 2 7 8 Rule At Pruning Rule Ba 4 1 3 0 5 6 2 7 8 Rule Ka 1 0 3 4 5 6 2 7 8 Pruning Depth - 1 Depth - 2 Solution Path 1 2 3 4 5 6 7 0 8 1 2 3 4 5 6 7 8 0 GS 1 0 3 4 5 6 2 7 8 Heuristik = 0 Rule Ki 0 1 3 1 5 3 Rule Ba IS 4 5 6 2 7 8 4 0 6 2 7 8 1 5 3 4 7 6 2 0 8 1 5 3 4 7 6 2 8 0 1 5 3 4 7 6 0 2 8 1 0 3 4 2 5 7 8 6 1 3 0 4 2 5 1 2 3 4 0 5 Heuristik = 4 Heuristik = 4 Heuristik = 4 Heuristik = 3 Heuristik = 2 Rule Ba Rule Ki Rule Ka Rule Ba Rule Ka Solution Path 4 2 5 7 8 6 4 0 5 7 8 6 Heuristik 2 1 2 3 4 5 0 7 8 6 1 2 3 0 4 5 7 8 6 1 2 3 4 8 5 7 0 6 Heuristik = 1 1 2 3 4 5 6 Heuristik = 0
