LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
LABORATORIUM PEMBELAJARAN ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
FAKULTAS ILMU KOMPUTER
UNIVERSITAS BRAWIJAYA
UNIVERSITAS BRAWIJAYA
BAB
BAB
:
: CONSTRAINT
CONSTRAINT SATISFACTION
SATISFACTION PROBLEM
PROBLEM
NAMA
NAMA
: -RENDY PUTRA JALIASMA
: -RENDY PUTRA JALIASMAR
R
-ABDUL KHALIK SEMBIRING
-ABDUL KHALIK SEMBIRING
-MUHAMMAD RIFQI
-MUHAMMAD RIFQI
-MUHAMMAD IQBAL ALVIN
-MUHAMMAD IQBAL ALVIN
NIM
NIM
: -16515020011
: -165150200111148
1148
-165150200111153
-165150200111153
-165150207111076
-165150207111076
-165150201111186
-165150201111186
TANGGAL
TANGGAL :
: 11/04/2018
11/04/2018
JENIS
JENIS
:
: TUGAS
TUGAS
ASISTEN
ASISTEN
:
: -DINDY
-DINDY FITRIANNORA
FITRIANNORA
-WINDYA HARTASIH
-WINDYA HARTASIH
ACC
ACC
A.
A. DEFINISI MASALAH
DEFINISI MASALAH
1. Modifikasilah program diatas sehingga dapat menyelesaikan permasalahan 1. Modifikasilah program diatas sehingga dapat menyelesaikan permasalahan
coloroing map pada peta pulau Sumatera di bawah ini. coloroing map pada peta pulau Sumatera di bawah ini.
Domain yang digunkana adalah maksimal 3 warna. Daerah yang digunakan adalah Domain yang digunkana adalah maksimal 3 warna. Daerah yang digunakan adalah provinsi yang telah
provinsi yang telah diberi nomdiberi nomor. Tentukan terleor. Tentukan terlebih dahulu constrabih dahulu constrain yang dibutuhkin yang dibutuhkan.an. Modofikasi pula metode
Modofikasi pula metode backtrackbacktracking diatas ing diatas dengan menambahkdengan menambahkan MRV an MRV (Most(Most Restricted Variable) Heuristic
B. JAWAB
Strategy.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 package ceespe; import java.util.*;public abstract class Strategy {
List<CSPStateListener> listeners = new ArrayList<CSPStateListener>();
public void addCSPStateListener(CSPStateListener listener){
listeners.add(listener); }
public void removeCSPStateListener(CSPStateListener listener){
listeners.remove(listener); }
protected void fireStateChanged(CSPProblem csp){ for(CSPStateListener listener : listeners){
listener.stateChanged(csp.copyDomains()); }
}
protected void fireStateChanged(Assignment assignment, CSPProblem csp){
for(CSPStateListener listener : listeners){ listener.stateChanged(assignment.copy(), csp.copyDomains());
} }
public abstract Assignment solve(); } Variable.java 1 2 3 4 5 6 7 8 9 package ceespe;
public class Variable {
private final String name; public Variable(String name){
this.name = name; }
public String getName(){ return name;
10 11 12 13 14 15 16 17 18 19 20 21 22 23 }
public String toString(){ return name;
}
public boolean equals(Object obj){ if(obj == null){ return false; } if(obj.getClass() == getClass()){ return this.name.equals(((Variable) obj).name); } return false; } } Assignment.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 package ceespe; import java.util.*;
public class Assignment { List<Variable> variables;
Hashtable<Variable, Object> variableToValue; public Assignment(){
variables = new ArrayList<Variable>(); variableToValue = new Hashtable<Variable, Object>();
}
public List<Variable> getVariables(){
return Collections.unmodifiableList(variables); }
public Object getValue(Variable var){ return variableToValue.get(var); }
public void assign(Variable var, Object value){ if(!variableToValue.containsKey(var)){
variables.add(var);
}variableToValue.put(var, value); }
public void removeAssignment(Variable var){ if(hasAssignmentFor(var)){
variables.remove(var);
variableToValue.remove(var); }
}
public boolean hasAssignmentFor(Variable var){ return variableToValue.get(var) != null;
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 59 60 61 62 63 64 65 66 67 68 }
public boolean isConsistent(List<Constraint> constraints){
for(Constraint cons : constraints){ if(!cons.satisfied(this)){
return false; }
}return true; }
public boolean isComplete(List<Variable> vars){ for(Variable var : vars){
if(!hasAssignmentFor(var)){ return false;
}
}return true; }
public Assignment copy(){
Assignment copy = new Assignment(); for(Variable var : variables){
copy.assign(var, variableToValue.get(var)); }return copy;
}
public String toString(){ boolean comma = false;
StringBuilder result = new StringBuilder(); for(Variable var : variables){
if(comma){ result.append(", "); }result.append(": ").append(variableToValue.get(var)); comma = true; } return result.toString(); }
public void printSolution(){
System.out.println("Solution"); for(Variable var : variables){
System.out.printf("%- 19s : %s\n",var,variableToValue.get(var)); } } } Backtrack.java 1 2 package ceespe;
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 CSPProblem problem;
public Backtrack(CSPProblem prob){ this.problem = prob;
}
public Assignment solve(){
return recursiveSolve(this.problem, new Assignment());
}
private Assignment recursiveSolve(CSPProblem csp, Assignment assignment){
Assignment result = null;
if(assignment.isComplete(csp.getVariables())){ result = assignment;
}else{
Variable var = unassignedVar(assignment,csp); for(Object value : orderValues(var,assignment,csp)){ assignment.assign(var, value); fireStateChanged(assignment, csp); if(assignment.isConsistent(csp.getConstraints(var))){ DomainInfo info = inference(var,assignment,csp); if(!info.isEmpty()){ fireStateChanged(csp); }if(!info.isEmptyDomainFound()){ result = recursiveSolve(csp, assignment); if (result != null){ break; } } info.restoreDomains(csp); } assignment.removeAssignment(var); } } return result; }
protected Variable unassignedVar(Assignment assignment, CSPProblem csp){
for(Variable var : csp.getVariables()){
if(!(assignment.hasAssignmentFor(var))){ return var;
46 47 48 49 50 51 52 53 54 55 56 57 } return null; }
protected Iterable<?> orderValues(Variable var, Assignment assignment, CSPProblem csp){
return csp.getDomain(var); }
protected DomainInfo inference(Variable var, Assignment assignment, CSPProblem csp){
return new DomainInfo().compactify(); } } Constraint.java 1 2 3 4 5 6 package ceespe; import java.util.List;
public interface Constraint { List<Variable> getScope();
abstract boolean satisfied (Assignment asgn); } CSPPProblem.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 package ceespe; import java.util.*;
public class CSPProblem {
private List<Variable> variables; private List<Domain> domains;
private List<Constraint> constraints;
private Hashtable<Variable, Integer> varIndexHash; private Hashtable<Variable, List<Constraint>> cnet; public CSPProblem(){
variables = new ArrayList<Variable>(); domains = new ArrayList<Domain>();
constraints = new ArrayList<Constraint>(); varIndexHash = new Hashtable<Variable, Integer>();
cnet = new Hashtable<Variable, List<Constraint>>();
}
public CSPProblem(List<Variable> vars){ this();
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 addVariable(v); } }
protected void addVariable(Variable var){ if(!varIndexHash.containsKey(var)){
Domain emptyDomain = new Domain(Collections.emptyList());
variables.add(var);
domains.add(emptyDomain);
varIndexHash.put(var, variables.size()-1); cnet.put(var, new ArrayList<Constraint>()); }else{
throw new IllegalArgumentException("Variable with same name already exists.");
} }
public List<Variable> getVariables(){
return Collections.unmodifiableList(variables); }
public int indexOf(Variable var){ return varIndexHash.get(var); }
public Domain getDomain(Variable var){
return domains.get(varIndexHash.get(var)); }
public void setDomain(Variable var, Domain domain){ domains.set(indexOf(var), domain);
}
public void removeValueFromDomain(Variable var, Object value){
Domain currDomain = getDomain(var); List<Object> values = new
ArrayList<Object>(currDomain.size()); for(Object v : currDomain){
if(!v.equals(value)){ values.add(v);
}setDomain(var, new Domain(values)); }
}
public void addConstraint(Constraint constraint){ constraints.add(constraint);
for(Variable var : constraint.getScope()){ cnet.get(var).add(constraint);
} }
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 return constraints; }
public List<Constraint> getConstraints(Variable var){ return cnet.get(var);
}
public CSPProblem copyDomains(){
CSPProblem result = new CSPProblem(); result.variables = variables; result.domains = new ArrayList<Domain>(domains.size()); result.domains.addAll(domains); result.constraints = constraints; result.varIndexHash = varIndexHash; result.cnet = cnet; return result; } } CSPStateListener.java 1 2 3 4 5 package ceespe;
public interface CSPStateListener {
void stateChanged(Assignment assignment, CSPProblem csp); void stateChanged(CSPProblem csp); } Domain.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 package ceespe; import com.sun.org.apache.xerces.internal.impl.xs. identity.ValueStore; import java.util.*;
public class Domain implements Iterable<Object> { private final Object[] values;
public Domain(List<?> values){
this.values = new Object[values.size()]; for (int i = 0; i < values.size(); i++) {
this.values[i] = values.get(i); }
}
public Domain(Object[] values){
this.values = new Object[values.length]; for (int i = 0; i < values.length; i++) {
this.values[i] = values[i]; }
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
public int size(){
return values.length; }
public Iterator<Object> iterator(){
return new ArrayIterator<Object>(values); }
class ArrayIterator<T> implements Iterator<T>{ T[] values;
int counter;
public ArrayIterator(T[] values){ this.values = values;
counter = 0; }
public boolean hasNext() {
return counter < values.length; }
public T next() {
return values[counter++]; }
public void remove(){
throw new UnsupportedOperationException(); } } } DomainInfo.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 package ceespe; import java.util.*;
public class DomainInfo {
private List<Pair<Variable, Domain>> savedDomains; private HashSet<Variable> affectedVariables;
private boolean emptyDomainObserved; public DomainInfo(){
savedDomains = new ArrayList<Pair<Variable, Domain>>();
affectedVariables = new HashSet<Variable>(); }
public void clear (){ savedDomains.clear();
affectedVariables.clear(); }
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
public boolean isEmpty(){
return savedDomains.isEmpty(); }
public void storeDomainFor(Variable var, Domain domain){
if(!affectedVariables.contains(var)){
savedDomains.add(new Pair<Variable, Domain>(var, domain));
affectedVariables.add(var); }
}
public void setEmptyDomainFounnd (boolean b){ emptyDomainObserved = b;
}
public DomainInfo compactify(){ affectedVariables = null; return this;
}
public boolean isEmptyDomainFound(){ return emptyDomainObserved;
}
public List<Pair<Variable, Domain>> getSavedDomains(){
return savedDomains; }
public void restoreDomains(CSPProblem csp){ for(Pair<Variable, Domain> pair :
getSavedDomains())
csp.setDomain(pair.getFirst(), pair.getSecond());
}
@Override
public String toString(){
StringBuilder result = new StringBuilder()
savedDomains.stream().forEach((Pair<Variable, Domain> pair) -> {result.append(pair.getFirst()).
append("=").append(pair.getSecond()).append(" "); });
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 return result.toString(); } class Pair<X,Y> { private final X a; private final Y b; public Pair (X a, Y b){ this.a = a; this.b = b; } public X getFirst(){ return a; } public Y getSecond(){ return b; } } } Main.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 package ceespe; public class Main {
public static void main(String[] args) { MapCSP map = new MapCSP();
Backtrack bts = new Backtrack(map);
bts.addCSPStateListener(new CSPStateListener() { @Override
public void stateChanged(Assignment assignment, CSPProblem csp) {
System.out.println("processing..."+assignment); }
@Override
public void stateChanged(CSPProblem csp){ System.out.println(csp);
} });
System.out.println("Map Coloring each city on Sumatra Island\n");
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
Assignment sol = bts.solve();
System.out.println("Backtracking completed!\n"); sol.printSolution();
} }
class MapCSP extends CSPProblem {
public static final Variable AC = new Variable("Aceh");
public static final Variable SU = new Variable("Sumatra Utara");
public static final Variable RI = new Variable("Riau");
public static final Variable SB = new Variable("Sumatra Barat");
public static final Variable JB = new Variable("Jambi");
public static final Variable SS = new Variable("Sumatra Selatan");
public static final Variable BK = new Variable("Bengkulu");
public static final Variable LP = new Variable("Lampung");
public static final String R = "Red"; public static final String G = "Green"; public static final String B = "Blue"; public MapCSP(){
collectVariables();
Domain colors = new Domain(new Object[]{R, G, B});
for(Variable var : getVariables()){ setDomain(var, colors);
}
addConstraint(new NotEqualConstraint(AC, SU)); addConstraint(new NotEqualConstraint(SU, RI)); addConstraint(new NotEqualConstraint(SU, SB)); addConstraint(new NotEqualConstraint(RI, JB)); addConstraint(new NotEqualConstraint(SB, JB)); addConstraint(new NotEqualConstraint(SB, RI)); addConstraint(new NotEqualConstraint(JB, BK)); addConstraint(new NotEqualConstraint(JB, SS)); addConstraint(new NotEqualConstraint(SU, RI)); addConstraint(new NotEqualConstraint(BK, SS));
58 59 60 61 62 63 64 65 66 67 68 69 70 71 addConstraint(new NotEqualConstraint(SS, LP)); }
private void collectVariables(){ addVariable(AC); addVariable(SU); addVariable(RI); addVariable(SB); addVariable(JB); addVariable(BK); addVariable(SS); addVariable(LP); } } NotEqualConstraint.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 package ceespe; import java.util.*;
public class NotEqualConstraint implements Constraint { private final Variable var1;
private final Variable var2;
private final List<Variable> scope;
public NotEqualConstraint (Variable var1, Variable var2){
this.var1 = var1; this.var2 = var2;
scope = new ArrayList<Variable>(2); scope.add(var1);
scope.add(var2); }
public List<Variable> getScope() { return scope;
}
public boolean satisfied(Assignment assignment){ Object value1 = assignment.getValue(var1); return value1 == null ||
!value1.equals(assignment.getValue(var2)); }
}
