Ingenier´ıa Inform´ atica Fundamentos de Inteligencia Artificial Hoja 2

Universidad Rey Juan Carlos
Curso 2011/2012
Ingenierı́a Informática
Fundamentos de Inteligencia Artificial
Hoja 2
1. Utilizando como referencia el código de ejemplo del de la Hoja 1, se busca modelar un
problema sencillo de búsqueda desde cero, utilizando las librerı́as de la asignatura para
poder solucionarlo.
El problema planteado es el clásico laberinto, compuesto por N ×M casillas. En cada uno
de los estados del juego, el jugador podrá optar realizar cualquier de los 4 movimientos
posibles: ARRIBA, ABAJO, IZQUIERDA y DERECHA. Las casillas deberán tener la
información necesaria para poder indicar si el movimiento se puede realizar.
La estrategia para abordar el problema es la siguiente: modelar el tipo (o tipos) de datos
que representan el estado y modelar las posibles acciones. Con el estado y las acciones,
crear un programa principal que haga uso de alguna de las estrategias (en este caso,
profundidad o anchura) para solucionar el problema.
Las acciones a modelar son las anteriormente indicadas, sin tener ninguna particularidad
en su coste. La clase que modela una acción deberá implementar la interfaz Action (junto
a esta hoja), implementando todos sus métodos.
El estado en cada paso del problema deberá tener la información necesaria para:
determinar todo el estado del juego (tablero y posición actual del jugador)
poder determinar si el estado actual es un estado solución
dada una de las acciones, poder generar un nuevo estado en el que se aplique dicha
acción
en un estado dado, poder generar todas las acciones posibles que se podrı́an aplicar
a dicho estado
dada un acción en un estado, establecer si dicha acción es factible o no
Para todo ello, el estado deberá heredar de la clase State, implementando todos sus
métodos abstractos (según se puede ver en el ejemplo de la hoja 1 o según el código del
anexo). Es de gran ayuda utilizar como referencia el ejemplo presentado en el ejemplo
anterior para entender su funcionamiento.
Además puede que se requiera algún tipo de datos adicional para implementar alguna
estructura de datos (¿el tablero del laberinto?, ¿las casillas?)
(a) A la hora de implementar el estado, ¿para qué puede servir el método equals del
estado?
(b) Con un tablero de un tamaño aproximado de 10 × 10, evaluar el funcionamiento de
las dos estrategias anteriormente utilizadas. ¿Es alguna estrategia mejor para este
problema en concreto?
1
Interfaz Action
1
2
package es . urjc . ia . fia . genericSearch . data ;
3
4
public interface Action {
5
public double cost ();
public int hashCode ();
public String toString ();
6
7
8
9
}
Clase abstracta State
1
2
package es . urjc . ia . fia . genericSearch . data ;
3
4
5
...
public abstract class State < ACTION extends Action > {
6
7
...
8
9
10
11
12
13
14
/* *
* Generic c o n s t r u c t o r . Just initial the s o l u t i o n list .
*/
public State () {
this . solution = new ArrayList < ACTION >();
}
15
16
17
18
19
20
21
22
23
/* *
* G e n e r a t e a new state apply the action to the current state .
* You can only use this method if <i > isValidAction </ i > returns
* <i > true </ i > for the same action .
* @param _action action to apply
*/
public abstract State < ACTION > applyAction ( ACTION _action ) throws Exception ;
24
25
26
27
28
29
30
31
32
33
/* *
* Return the partial s o l u t i o n . If <i > isSolution </ i > is true , this is the
* solution .
* @return partial s o l u t i o n
*/
public final List < ACTION > g e t P a r t i a l S o l u t i o n () {
...
}
34
35
36
37
38
39
40
/* *
* D e t e r m i n e if the action is valid for the current state
* @param _action
* @return
*/
public abstract boolean isValidAction ( ACTION _action );
41
42
43
44
45
46
47
48
49
/* *
* Return a list of valid actions for the current state . I m p l e m e n t s
* g e n e r a t i n g all p o s s i b l e action and verify if this action is valid
* for the current state with the <i > isValidAction </ i > method .
* @return set of valid action for the current state
*/
public abstract Collection < ACTION > g e t A p p l i c a b l e A c t i o n s ();
50
51
52
53
54
55
56
/* *
* D e t e r m i n e if the current state is a s o l u t i o n state
* @return
*/
public abstract boolean isSolution ();
57
2
58
/* ( non - Javadoc )
* @see java . lang . Object # clone ()
*/
@Override
public abstract Object clone () throws C l o n e N o t S u p p o r t e d E x c e p t i o n ;
59
60
61
62
63
64
65
/* *
* Method to use in the clone s p e c i f i c i m p l e m e n t a t i o n :
* copy the s o l u t i o n .
* @param _state
*/
protected void c o p y P a r t i a l S o l u t i o n F r o m ( State < ACTION > _state ) {
...
}
66
67
68
69
70
71
72
73
74
@Override
public abstract boolean equals ( Object obj );
75
76
77
78
/* *
* Add new action to the s o l u t i o n
* @param _action
* @return
*/
protected final boolean a d d A c t i o n T o S o l u t i o n ( ACTION _action ) {
...
}
...
79
80
81
82
83
84
85
86
87
88
}
3