LABORATORIUM PEMBELAJARAN ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA
BAB : UNINFORM SEARCH
NAMA : KELOMPOK V
NIM :- ACC
TANGGAL : 17/02/2020
JENIS : TUGAS
ASISTEN : - PRATITHA VIDYA SAKTA
- THREECIA AGIL REGITASARI

A. DEFINISI MASALAH

Buatlah program dengan menggunakan algoritma Uniform-cost Search dengan

memodifikasi program BFS pada halaman sebelumnya (Uniform-cost Search
mirip dengan BFS, tetapi mempertimbangakan nilai cost, atau dalam kasus ini
adalah nilai jarak antar node) pada pencarian rute berikut ini:

Input:

a. Kota asal
b. Kota Tujuan

Output:

a. Langkah-langkah pencarian rute

b. Rute yang merupakan solusi dan jarak yang ditempuh

Kasus khusus yang wajib diujikan:

a. Kota A ke kota D
b. Kota H ke kota N
c. Kota H ke kota U
d. Kota O ke H
e. Kota I ke A

B. JAWAB
A. Source Code
UCS.java
1 package ucs;
2 import java.util.ArrayList;
3 import java.util.Collections;
4 import java.util.Comparator;
5 import java.util.HashSet;
6 import java.util.List;
7 import java.util.PriorityQueue;
8 import java.util.Set;
9
10 public class UCS {
11
12 public static void findUCS(Node initialState, Node
goalState) {
13 initialState.pathCost = 0;
14 PriorityQueue<Node> queue = new
PriorityQueue<Node>(20,
new Comparator<Node>() {
15 public int compare(Node i, Node j) {
16 if (i.pathCost > j.pathCost) {
17 return 1;
18 } else if (i.pathCost < j.pathCost) {
19 return -1;
20 } else {
21 return 0;
22 }
23 }
24 }
25 );
26 queue.add(initialState);
27 Set<Node> explored = new HashSet<Node>();
28 List<Node> currentExplore = new ArrayList<Node>();
29 boolean found = false;
30 do {
31 Node current = queue.poll();
32 explored.add(current);
33 if (current.value.equals(goalState.value)) {
34 found = true;
35 }
36 for (Edge e : current.adjacencies) {
37 Node child = e.target;
38 double cost = e.cost;
39 if (!explored.contains(child) && !
40 queue.contains(child)) {
41 child.pathCost = current.pathCost + cost;
42 child.parent = current;
43 queue.add(child);
44 } else if ((queue.contains(child)) &&
45 (child.pathCost > (current.pathCost + cost))) {
46 child.parent = current;
47 child.pathCost = current.pathCost + cost;
48 queue.remove(child);
49 queue.add(child);
50 }
51 }
52 currentExplore.add(current);
53 } while (!queue.isEmpty() && (found == false));
54 System.out.println("Explored Node: " +
55 currentExplore);
56 }
57
58 public static List<Node> showShortest(Node target) {
59 List<Node> path = new ArrayList<Node>();
60 for (Node node = target; node != null; node =
61 node.parent) {
62 path.add(node);
63 }
64 Collections.reverse(path);
65 return path;
66 }
67 }

Node.java
1 package ucs;
2
3 public class Node {
4
5 public final String value;
6 public double pathCost;
7 public Edge[] adjacencies;
8 public Node parent;
9
10 public Node(String val) {
11 value = val;
12 }
13
14 public String toString() {
15 return value;
16 }
17 }
18
19 class Edge {
20
21 public final double cost;
22 public final Node target;
23
24 public Edge(Node targetNode, double costVal) {
25 cost = costVal;
26 target = targetNode;
27 }
28 }

Main.java
1 package ucs;
2
3 import java.util.List;
4
5 public class Main {
6
7 public static void main(String[] args) {
8 Node cityA = new Node("A");
9 Node cityB = new Node("B");
10 Node cityC = new Node("C");
11 Node cityD = new Node("D");
12 Node cityE = new Node("E");
13 Node cityF = new Node("F");
14 Node cityG = new Node("G");
15 Node cityH = new Node("H");
16 Node cityI = new Node("I");
17 Node cityJ = new Node("J");
18 Node cityK = new Node("K");
19 Node cityL = new Node("L");
20 Node cityM = new Node("M");
21 Node cityN = new Node("N");
22 Node cityO = new Node("O");
23 Node cityP = new Node("P");
24 Node cityQ = new Node("Q");
25 Node cityR = new Node("R");
26 Node cityS = new Node("S");
27 Node cityT = new Node("T");
28 Node cityU = new Node("U");
29 Node cityV = new Node("V");
30 Node cityX = new Node("X");
31
32
33 cityA.adjacencies = new Edge[]{
34 new Edge(cityB, 145),
35 new Edge(cityI, 148),
36 new Edge(cityX, 55),
37 new Edge(cityV, 167)
38 };
39 cityB.adjacencies = new Edge[]{
40 new Edge(cityA, 145),
41 new Edge(cityC, 98)
42 };
43 cityC.adjacencies = new Edge[]{
44 new Edge(cityB, 98),
45 new Edge(cityD, 212)
46 };
47 cityD.adjacencies = new Edge[]{
48 new Edge(cityC, 212),
49 new Edge(cityE, 102),
50 new Edge(cityK, 102)
51 };
52 cityE.adjacencies = new Edge[]{
53 new Edge(cityD, 102),
54 new Edge(cityM, 73),
55 new Edge(cityN, 97),
56 new Edge(cityF, 152),
57 new Edge(cityL, 95)
58 };
59 cityF.adjacencies = new Edge[]{
60 new Edge(cityE, 152),
61 new Edge(cityG, 83)
62 };
63 cityG.adjacencies = new Edge[]{
64 new Edge(cityF, 83),
65 new Edge(cityH, 75)
66 };
67 cityH.adjacencies = new Edge[]{
68 new Edge(cityG, 75)
69 };
70 cityI.adjacencies = new Edge[]{
71 new Edge(cityA, 148),
72 new Edge(cityJ, 75),
73 new Edge(cityQ, 25)
74 };
75 cityJ.adjacencies = new Edge[]{
76 new Edge(cityI, 75),
77 new Edge(cityK, 95)
78 };
79 cityK.adjacencies = new Edge[]{
80 new Edge(cityJ, 95),
81 new Edge(cityD, 102)
82 };
83 cityL.adjacencies = new Edge[]{
84 new Edge(cityE, 95)
85 };
86 cityM.adjacencies = new Edge[]{
87 new Edge(cityE, 73)
88 };
89 cityN.adjacencies = new Edge[]{
90 new Edge(cityE, 97),
91 new Edge(cityO, 25),
92 new Edge(cityP, 65)
93 };
94 cityO.adjacencies = new Edge[]{
95 new Edge(cityN, 25)
96 };
97 cityP.adjacencies = new Edge[]{
98 new Edge(cityN, 65)
99 };
100 cityQ.adjacencies = new Edge[]{
101 new Edge(cityI, 25),
102 new Edge(cityX, 30)
103 };
104 cityR.adjacencies = new Edge[]{
105 new Edge(cityS, 93),
106 new Edge(cityX, 57)
107 };
108 cityS.adjacencies = new Edge[]{
109 new Edge(cityR, 93),
110 new Edge(cityT, 112)
111 };
112 cityT.adjacencies = new Edge[]{
113 new Edge(cityS, 112),
114 new Edge(cityU, 75),
115 new Edge(cityV, 25)
116 };
117 cityU.adjacencies = new Edge[]{
118 new Edge(cityT, 75),
119 new Edge(cityV, 85)
120 };
121 cityV.adjacencies = new Edge[]{
122 new Edge(cityU, 85),
123 new Edge(cityT, 25),
124 new Edge(cityA, 167)
125 };
126 cityX.adjacencies = new Edge[]{
127 new Edge(cityA, 55),
128 new Edge(cityR, 57),
129 new Edge(cityQ, 30)
130 };
131
132 UCS.findUCS(cityI, cityA);
133 List<Node> path = UCS.showShortest(cityA);
134 System.out.println("Path: " + path);
System.out.println("Cost: " + cityA.pathCost);
135 }
136 }

B. Penjelasan Source Code

UCS.java
1 Deklarasi package bernama ucs.
2 Deklarasi fungsi ArrayList dari kelas Java.
3 Deklarasi fungsi Collections dari kelas Java.
4 Deklarasi fungsi Comparator dari kelas Java.
5 Deklarasi fungsi HashSet dari kelas Java.
6 Deklarasi fungsi List dari kelas Java.
7 Deklarasi fungsi PriorityQueue dari kelas Java.
8 Deklarasi fungsi Set dari kelas Java.
10 Deklarasi kelas bernama findUCS dengan parameter Node asal dan Node
tujuan
12-67 Method findUCS digunakan untuk menentukan jarak terdekat dari
initalState menuju goalState yang merupakan paramater dalam method
findUCS pathCost memiliki nilai 0 yang berarti merupakan dari initalState.
PriorityQueue bernama queue melakukan override terhadap method
compare.Method compare bertugas dalam membandingkan pathCost antar
Node.Terdapat instansiasi objek berjenis Set dan List yang digunakan
untuk menyimpan Node yang akan terhubung.Selanjutnya, ada bagian
perulangan dengan seleksi kondisi yang bertindak untuk penelusuran
terhadapNode serta menjumlahkan cost ketika melakukan penelusuran
Node.Hasil dari method ini menampilkan langkah-langkah pencarian rute.
Method showShortest berguna untuk menampilkan jarak terdekat setalah
ditentukan initalState dan goalState.

Node.java
1 Deklarasi package dengan nama ucs
3-17 Deklarasi kelas dengan nama node yang berisikan deklarasi-deklarasi
atribut dari Node tersebut yang akan digunakan dalam Uniformed Search.
Node memiliki nilai yaitu value sebagai nama dari node, adjacencies
sebagai list node yang terhubung dengan node utama, pathCost untuk
memberikan nilai pada path yang terhubung dengan node ini. Node parent
sebagai nilai node parent dari node ini. terdapat constructor untuk
memberikan nilai pada object node berupa string. terdapat method toString
untuk mencetak nilai dari node
19-28 Deklarasi method Edge yang berisikan deklarasi-deklarasi atribut dari
Edge sendiri yang bertujuan untuk menyambungkan antara satu node
dengan node yang lain. Kemudian jalur dari node satu dengan node lain
akan diberi cost. Terdapat constructor untuk memberikan nilai pada atribut
targetNode dan costVal.

Main.java
1 Deklarasi package dengan nama ucs
3 Deklarasi kelas dengan nama main class ini terdapat method main yang
dapat melakukan inisialisasi node dengan parameter nama kota. Kemudian
membuat koneksi dari node kepada node lain dan menambahkan cost darij
alur tersebut. Diakhir dari program akan mengeluarkan jalur dari
penelusuran, jalur terdekat dan nilai dari path
8-30 Instansiasi objek Node dengan parameter String
33-130 Pemanggilan variable adjencencies oleh objek tertentu dengan parameter
objek tertentu terhubung dengan node apa saja dan jaraknya berapa.
132 Pemanggilan method findUCS dengan parameter inputan initial state dan
goal state.
133 Instansiasi List path dengan method showShortest dengan parameter goal
state.
134 Mencetak jalur yang ditempuh dari state awal hingga goal state.
135 Tanda tutup method main.
 136 Tanda tutup kelas.
C. Screenshot
a. Kota A ke kota D

b. Kota H ke kota N

c. Kota H ke kota U

d. Kota O ke H

e. Kota I ke A

D. KESIMPULAN

1. Jelaskan apa maksud dan komponen dari problem solving agent?

Jawab : Bentuk permasalahan yang bisa diselesaikan dengan algortima tersebut
adalah menentukan rute sebuah tempat yang akan menjadi tujuan perjalanan.
Algoritma ini akan mengarahkan kita pergi dari tempat asal menuju tempat tujuan
melalui tempat-tempat disekitar terdekat sampai menemukan tempat tujuan
perjalanan(goal).
2. Mengapa depth first search digolongkan sebagai algoritma yang tidak optimal dan
tidak complete?
Jawab : Depth first search adalah algoritma berdasarkan ekspansi node dari root
sampai ke node yang terdalam. DFS ini me jadi tidak komplit apabila terdapat
banyak level pada tree atau state space dengan looping karena tidak ada jaminan
untuk solusi. Selain itu, apabila pada DFS terdapat lebih dari satu solusi yang
 sama tetapi berada pada level yang berbeda , DFS menjadi tidak optimal.
3. Jelaskan perbedaan algoritma UCS dan BFS dari segi implementasi!
Jawab : Algoritma UCS(Uniform Cost Search) memulai pencarian dari root node,
kemudian berlanjut ke node-node selanjutnya dimana node tersebut dipilih
dengan syarat yang memilki harga (cost) terkecil dari root node. Algoritma ini
melibatkan semua node yang berhubungan dengan root node dan meletakannya
dalam priority queue untuk mencapai node tujuan dan node – node yang dipilih
merupakan node yang memiliki harga terkecil/efisien dari segi harga.
Sedangkan algoritma BFS(Breadth First Search) bekerja dengan mencari satu per
satu node secara melebar dan berurutan dari kiri ke kanan berdasarkan tingkat
level nodenya. Setiap node yang telah dikunjungi harus dimasukkan dalam sebuah
queue (antrian) sebagai tempat menampung urutan node tahap demi tahap.Jika
pada satu level belum ditemukan solusi yang diinginkan, maka pencarian
dilanjutkan hingga level berikutnya, kemudian demikian seterusnya hingga
ditemukan solusi.