Tugas AI forum
1. Adversarial search dan Constraints Satisfaction problem
Adversarial search merupakan metode pencarian yang pada dasarnya bekerja dengan cara
menemukan berbagai kemungkinan yang ada dalam mengatasi sebuah masalah baik itu
yang merupakan efektif maupun yang tidak akan tetap dicari berbagai kemungkinan yang
ada . Contoh Implementasinya ada di permainan catur , dalam permainan ini tentu saja
banyak sekali kemungkinan untuk sebuah pion catur bergerak dan juga banyak konfigurasi
hasil dari papan catur , dan dari user sendiri bisa menentukan dari berbagai kemungkinan
bergerak yang ada manakah yang merupakan strategi yang efektif dalam menghadapi
lawannya. Bagaimana melakukannya ? yaitu dengan menggunakan algoritma pencarian
contohnya : mini-maks algoritma dan algoritma Alpha-beta.
Mini-Maks Algoritma
Algoritma mini-maks menjadi suatu dasar dalam sistem permainan AI seperti catur , othello
dan lain - lain , dimana cara kerjanya membuka dan mencari berbagai kemungkinan yang
ada dalam bermain permainan tersebut hingga akhir game selesai . Kerugiannya sangat
membutuhkan sumber daya yang besar untuk melakukan proses tersebut tetapi
keuntungannya melalui algoritma mini - maks ini dapat mengidentifikasikan kemungkinan
posisi berjalan yang terbaik untuk menghasilkan keputusan akhir yang terbaik juga , karena
sistem dari algoritma mini-maks berjalan rekursif hingga membuat lawan mendapatkan
kerugian yang minimum. Hasil dari pencarian berbagai kemungkinan jalan dan posisi yang
yang ada menghasilkan sebuah pohon permainan yang nanti akan diidentifikasikan mana
yang termasuk kemungkinan yang terbaik. Dalam penentuan keputusan max/min tersebut
dibutuhkan suatu nilai yang merepresentasikan kerugian atau keuntungan yang akan
diperoleh jika langkah tersebut dipilih. Untuk itulah disini digunakan sebuah fungsi heuristik.
Fungsi heuristik yang digunakan algoritma ini adalah fungsi heuristik statis (Kusumadewi,
2003). Fungsi heuristik digunakan untuk mengevaluasi nilai sebagai nilai yang
merepresentasikan hasil permainan yang akan terjadi jika langkah tersebut dipilih. Dari nilainilai heuristik inilah komputer akan menentukan simpul mana dari pohon permainan yang
akan dipilih, tentunya simpul yang akan dipilih tersebut adalahsimpul dengan nilai heuristik
yang akan menuntun permainan ke hasil akhir yang menguntungkan bagi computer
Constraints Satisfaction problem
defnisi : Merupakan sebuah problem matematika yang didefinisikan sebagai suatu set objek
yang kondisinya harus dapat memenuhi sejumlah batasan . Constraints Satisfaction Problem
merepresentasikan entitas dalam sebuah problem sebagai kolek homogen atas variabel,
yang diselesaikan dengan menggunakan metode Contraints Satisfaction.
contoh : Map coloring , dimana dalam pemetaannya kedua negara atau wilayah yang
berdampingan tidak boleh memiliki warna yang sama untuk membedakan.
2. Proporsional Logic
sebuah logika yang menangani atau memproses dan memanipulasi penarikan kesimpulan
yang logis dari setiap pernyataan yang hanya memiliki nilai benar atau salah .
Contoh:
A= Anda rajin belajar.
B = Anda lulus ujian.
C = Anda senang.
Bentuk argumen :
Jika A, maka B
Jika B, maka C
Jika A maka C
Pernyataan 1 dan 2 merupakan premis-premis dari argumen, sedangkan pernyataan 3
merupakan kesimpulan yang berasal dari premis-premisnya.
p
q
p^q
pvq
~p
: Hari ini hujan
: Murid-murid diliburkan dari sekolah
: Hari ini hujan dan murid-murid diliburkan dari sekolah
: Hari ini hujan atau murid-murid diliburkan dari sekolah
: Tidak benar hari ini hujan (atau: Hari ini tidak hujan)
3. Algoritma A*
package aStar;
import java.util.ArrayList;
import java.util.Collections;
import aStar.heuristics.AStarHeuristic;
import aStar.utils.Logger;
public class AStar {
private AreaMap map;
private AStarHeuristic heuristic;
//private int startX;
//private int startY;
//private int goalX;
//private int goalY;
/**
* closedList The list of Nodes not searched yet, sorted by their distance to the goal as guessed
by our heuristic.
*/
private ArrayList<Node> closedList;
private SortedNodeList openList;
private Path shortestPath;
Logger log = new Logger();
AStar(AreaMap map, AStarHeuristic heuristic) {
this.map = map;
this.heuristic = heuristic;
closedList = new ArrayList<Node>();
openList = new SortedNodeList();
}
public Path calcShortestPath(int startX, int startY, int goalX, int goalY) {
//this.startX = startX;
//this.startY = startY;
//this.goalX = goalX;
//this.goalY = goalY;
//mark start and goal node
map.setStartLocation(startX, startY);
map.setGoalLocation(goalX, goalY);
//Check if the goal node is blocked (if it is, it is impossible to find a path there)
if (map.getNode(goalX, goalY).isObstacle) {
return null;
}
map.getStartNode().setDistanceFromStart(0);
closedList.clear();
openList.clear();
openList.add(map.getStartNode());
//while we haven't reached the goal yet
while(openList.size() != 0) {
//get the first Node from non-searched Node list, sorted by lowest distance from our
goal as guessed by our heuristic
Node current = openList.getFirst();
// check if our current Node location is the goal Node. If it is, we are done.
if(current.getX() == map.getGoalLocationX() && current.getY() ==
map.getGoalLocationY()) {
return reconstructPath(current);
}
//move current Node to the closed (already searched) list
openList.remove(current);
closedList.add(current);
//go through all the current Nodes neighbors and calculate if one should be our next
step
for(Node neighbor : current.getNeighborList()) {
boolean neighborIsBetter;
//if we have already searched this Node, don't bother and continue to the next
one
if (closedList.contains(neighbor))
continue;
//also just continue if the neighbor is an obstacle
if (!neighbor.isObstacle) {
// calculate how long the path is if we choose this neighbor as the next step in
the path
float neighborDistanceFromStart = (current.getDistanceFromStart() +
map.getDistanceBetween(current, neighbor));
//add neighbor to the open list if it is not there
if(!openList.contains(neighbor)) {
openList.add(neighbor);
neighborIsBetter = true;
//if neighbor is closer to start it could also be better
} else if(neighborDistanceFromStart < current.getDistanceFromStart()) {
neighborIsBetter = true;
} else {
neighborIsBetter = false;
}
// set neighbors parameters if it is better
if (neighborIsBetter) {
neighbor.setPreviousNode(current);
neighbor.setDistanceFromStart(neighborDistanceFromStart);
neighbor.setHeuristicDistanceFromGoal(heuristic.getEstimatedDistanceT
oGoal(neighbor.getX(), neighbor.getY(), map.getGoalLocationX(), map.getGoalLocationY()));
}
}
}
}
return null;
}
public void printPath() {
Node node;
for(int x=0; x<map.getMapWith(); x++) {
if (x==0) {
for (int i=0; i<=map.getMapWith(); i++)
System.out.print("-");
System.out.println();
}
System.out.print("|");
for(int y=0; y<map.getMapHeight(); y++) {
node = map.getNode(x, y);
if (node.isObstacle) {
System.out.print("X");
} else if (node.isStart) {
System.out.print("s");
} else if (node.isGoal) {
System.out.print("g");
} else if (shortestPath.contains(node.getX(), node.getY())) {
System.out.print("¤");
} else {
System.out.print(" ");
}
if (y==map.getMapHeight())
System.out.print("_");
}
System.out.print("|");
System.out.println();
}
for (int i=0; i<=map.getMapWith(); i++)
System.out.print("-");
}
private Path reconstructPath(Node node) {
Path path = new Path();
while(!(node.getPreviousNode() == null)) {
path.prependWayPoint(node);
node = node.getPreviousNode();
}
this.shortestPath = path;
return path;
}
private class SortedNodeList {
private ArrayList<Node> list = new ArrayList<Node>();
public Node getFirst() {
return list.get(0);
}
public void clear() {
list.clear();
}
public void add(Node node) {
list.add(node);
Collections.sort(list);
}
public void remove(Node n) {
list.remove(n);
}
public int size() {
return list.size();
}
public boolean contains(Node n) {
return list.contains(n);
}
}
}
Algoritma A
package d;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class a {
final int MAX = 100;
// This array holds the flight information.
d flights[] = new d[MAX];
int numFlights = 0; // number of entries in flight array
Stack btStack = new Stack(); // backtrack stack
Stack optimal; // holds optimal solution
int mincost = 10000;
public static void main(String args[]) {
String to, from;
a ob = new a();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
boolean done = false;
d f;
ob.setup();
try {
System.out.print("From? ");
from = br.readLine();
System.out.print("To? ");
to = br.readLine();
do {
ob.isflight(from, to);
if (ob.btStack.size() == 0)
done = true;
else {
ob.route(to);
ob.btStack = new Stack();
}
} while (!done);
// Display optimal solution.
if (ob.optimal != null) {
System.out.println("Optimal solution is: ");
int num = ob.optimal.size();
for (int i = 0; i < num; i++) {
f = (d) ob.optimal.pop();
System.out.print(f.from + " to ");
}
System.out.println(to);
System.out.println("minium cost is " + ob.mincost);
}
} catch (IOException exc) {
System.out.println("Error on input.");
}
}
// Initialize the flight database.
void setup() {
addFlight("Mexico", "Stadium", 900);
addFlight("Stadium", "4_killo", 1000);
addFlight("Stadium", "Megengna", 500);
addFlight("4_killo", "Megengna", 1800);
addFlight("4_killo", "6_killo", 1700);
addFlight("Mexico", "Pissa",2500);
addFlight("Pissa", "6_killo", 500);
addFlight("6_killo", "4_killo",1000);
addFlight("Stadium", "Pissa", 1000);
addFlight("Pissa", "4_killo", 1500);
addFlight("Mexico", "Kera", 1000);
//addFlight("Kera", "Stadium", 15);
}
// Put flights into the database.
void addFlight(String from, String to, int dist) {
if (numFlights < MAX) {
flights [numFlights] = new d(from, to, dist);
numFlights++;
} else
System.out.println("Flight database full.\n");
}
// Save shortest route.
void route(String to) {
int dist = 0;
d f;
int num = btStack.size();
Stack optTemp = new Stack();
for (int i = 0; i < num; i++) {
f = (d) btStack.pop();
optTemp.push(f); // save route
dist += f.cost;
}
// If shorter, keep this route
if (mincost > dist) {
optimal = optTemp;
mincost = dist;
}
}
/*
* If there is a flight between from and to, return the distance of flight;
* otherwise, return 0.
*/
int match(String from, String to) {
for (int i = numFlights - 1; i > -1; i--) {
if (flights[i].from.equals(from) && flights[i].to.equals(to)
&& !flights[i].skip) {
flights[i].skip = true; // prevent reuse
return flights[i].cost;
}
}
return 0; // not found
}
// Given from, find any connection using least-cost.
d find(String from) {
int pos = -1;
int dist = 10000; // longer than longest route
for (int i = 0; i < numFlights; i++) {
if (flights[i].from.equals(from) && !flights[i].skip) {
// Use the shortest flight.
if (flights[i].cost < dist) {
pos = i;
dist = flights[i].cost;
}
}
}
if (pos != -1) {
flights[pos].skip = true; // prevent reuse
d f = new d(flights[pos].from, flights[pos].to,
flights[pos].cost);
return f;
}
return null;
}
// Determine if there is a route between from and to.
void isflight(String from, String to) {
int dist;
d f;
// See if at destination.
dist = match(from, to);
if (dist != 0) {
btStack.push(new d(from, to, dist));
return;
}
// Try another connection.
f = find(from);
if (f != null) {
btStack.push(new d(from, to, f.cost));
isflight(f.to, to);
} else if (btStack.size() > 0) {
// Backtrack and try another connection.
f = (d) btStack.pop();
isflight(f.from, f.to);
}
}
Sumber Referensi :
http://rinaforall.blogspot.com/2013/04/algoritma-minimax.html
http://digilib.ittelkom.ac.id/index.php?option=%20com_content&view=article&id=1090:alg
oritma-minimax&catid=21:itp-informatika-teori-dan-pemograman&Itemid=14
http://id.wikipedia.org/wiki/Minimax
http://jar28pratama.blogspot.com/2010/12/algoritma-google-search.html
Russel,Stuart dkk.2010.Artificial Intelegence - A Modern Approach.New Jersey : Pearson