Examen de Inteligencia Artificial.

16/01/ 2023

Duración total del examen: 3 horas

Ejercicio 1 [1,5 puntos]

En la empresa “ACME corporation” tienen que repartir tareas entre distintos

trabajadores. Los sindicatos y la empresa han negociado que una de las tareas
más duras debe repartirse entre trabajadores con distinta cualificación, debiendo
participar personal de las tres categorías profesionales. La tarea puede repartirse
en tres actividades, en las que cada categoría de personal se caracteriza por
llevarla a cabo en un tiempo determinado, y a un coste diferente. El reparto
debe realizarse de forma que se realice con un coste inferior a 100 euros, en el
menor tiempo posible, y utilizando los tres tipos de categoría profesional. La
tabla siguiente representa las tres actividades a realiza por empleados de
distintas categorías, mostrando el coste en euros, y el tiempo empleado en horas.
Actividad 1 Actividad2 Actividad3
E1:Empleado 15€, 40 h 12 €, 30 h 30 €, 20 h
categoría 1
E2:Empleado 40€, 36h 30€, 25 h 20€, 15 h
categoría 2
E3:Empleado 45€, 20h 40€, 25 h 40 €, 5 h
categoría 3

El problema consiste en decidir qué actividad se asignará a cada categoría de

empleado, de modo que se minimice el tiempo total respetando las
restricciones de coste monetario y la política negociada por la empresa y los
sindicatos. Los técnicos deciden utilizar el algoritmo A* en árbol para resolver
el problema.
(a) Define una representación del problema, especificando el conjunto de
posibles estados, estado inicial, estados finales, así como operador(es) y
su coste (0,25 puntos)
(b) Define dos buenas funciones heurísticas h optimistas (admisibles) para
el problema. Comenta como has llegado a definir cada una de las
heurísticas. (0,25 puntos)
(c) Desarrolla el árbol de búsqueda que genera el algoritmo A* para
una de las heurísticas que has propuesto. Indica el orden en el que se
expanden los nodos y los valores de f, g y h para cada nodo del árbol de
búsqueda. Muestra el estado de la FRONTERA y EXPLORADOS, si
procede, en cada ciclo de la búsqueda. En caso de empate en la función
heurística, considera que se expanden primero los nodos que has
dibujado más a la izquierda en tu árbol de búsqueda. (1 punto)
 (a) Define una representación del problema, especificando el conjunto de
posibles estados, estado inicial, estados finales, así como operador(es) y
su coste (0,25 puntos)

¡ ESTADO: Un estado se puede representar por una tupla de tres elementos, en la que el
primer elemento representa a que categoría de empleado se asigna la primera
actividad, el segundo elemento la categoría a la que se asigna la segunda actividad, y
el tercero la categoría a la que se asigna la tercera actividad. Los elementos no
asignados podemos representarlos en blanco, o de forma incremental ir representando
tuplas de 1, 2 y 3 elementos. Las restricciones del estado son que no se pueden repetir
categoría de empleado, y el coste económico no puede superar 100 euros, por lo que
incluiremos también el coste acumulado por las obras asignadas en el estado.
Representamos el estado con la tupla ([Ei, Ej, Ek], C) con i≠j, j≠k, y i≠k, y C es el
coste en Euros donde:
¡ Ei ∈ {E1, E2, E3, null} donde null indica no asignado. Utilizaremos una
representación incremental, asignando en orden de actividades.
Representaremos [null, null, null] con [], [Ei, null, null] con [Ei ] y [Ei, Ej,
null] con [Ei, Ej] .
¡ C ∈ [0,100] indica el coste acumulado por las diferentes categorías de
empleados en hacer las actividades asignadas.
Estado inicial : ([], )
Estado objetivo: ([Ei, Ej, Ek], C)

El modelo de transiciones debe representar las precondiciones de cada acción y sus efectos

Acciones Precondiciones Resultado

AsignarActividad1
AsignarActividad2
AsignarActividad3
([],0), coste(Ei,A1)€<=100
([Ei],t),
C+coste(Ej,A2)€<=100, i≠j
([Ei,Ej],t)
C+coste(Ek,A3)€<=100, i≠k,
j≠k
([Ei], coste(Ei,Tri)€)
([Ei, Ej], C+coste(Ej,Tr2)€)
([Ei, Ej, Ek],
C+coste(Ek,Tr3)€),

Coste camino = Suma de tiempos en horas de las actividades asignadas. ¡Ten en cuenta que
nos piden optimizar el tiempo!

(b) Define dos buenas funciones heurísticas h optimistas (admisibles) para

el problema. Comenta como has llegado a definir cada una de las
heurísticas. (0,25 puntos)
Define dos heurísticas: Las heurísticas las obtenemos de relajar las restricciones del
problema que son las restricciones de coste monetario y la política de empresa.

h1: La primera heurística para calcular el tiempo de las actividades por asignar relaja las
dos restricciones, permitiendo que la suma de costes de las obras asignadas sea mayor que
100 horas, y repetir empresas para estimar el tiempo de los tramos sin asignar. Se permite
repetir empresas entre las pendientes de asignar. Permitir repetir utilizando las ya
asignadas es admisible pero no aporta nada de información a la heurística. Se calcula
sumando los mínimos de las columnas de las empresas pendientes de asignar.
 Examen de Inteligencia Artificial.
16/01/ 2023

Duración total del examen: 3 horas

h2: La segunda heurística, más informada, sólo relaja la opción de repetir las empresas
para estimar el tiempo de los tramos sin asignar. Es decir, la heurística permite repetir
empresas de las pendientes por asignar, pero sólo si el coste es inferior a 100 euros. El
cálculo es cómo el de la h1, pero al tener en cuenta la restricción de precio hay que buscar
la combinación de valor menor que respete el precio. Este cálculo es más costoso que el
de la h1.

Ambas heurísticas son optimistas al relajar las restricciones del problema.

(c) Desarrolla el árbol de búsqueda que genera el algoritmo A* para una

de las heurísticas que has propuesto. Indica el orden en el que se
expanden los nodos y los valores de f, g y h para cada nodo del árbol de
búsqueda. Muestra el estado de la FRONTERA y EXPLORADOS, si
procede, en cada ciclo de la búsqueda. En caso de empate en la función
heurística, considera que se expanden primero los nodos que has
dibujado más a la izquierda en tu árbol de búsqueda. (1 punto)

Árbol Exploración con la heurística h1.

Heurística: Se pueden repetir las no 1 ([],0)

asignadas y no respetamos coste. 50= 0+(20+25+5)

([E1],15) ([E2],40) 2 ([E3],45)

70= 40+ (25+5) 66= 36+ (25+5) 60= 20+ (25+15)

3
No hay posibilidad de que se repitan
([E3,E1],57) ([E3,E2],75)
estados. Cómo las heurísticas
(20+30)+( 15)=65 65=(20+25)+20
propuestas/pedidas deben ser
admisibles, y no aporta nada que sea 4
en grafo, hacemos la búsqueda en ([E3,E1,E2],77)
árbol. No hay lista de expandido, solo 65=(20+30+15)
frontera
Objetivo
Frontera
1) ([],0]50
2) ([E3],45)60 ([E2], 40)66 ([E1], 15)70
3) ([E3,E1],57) 65 ([E3,E2],75) 65 ([E2], 40)66 ([E1], 15)70
4) ([E3,E1,E2],77) 65 ([E3,E2],70) 65 ([E2], 40)66 ([E1], 15)70
Test objetivo al expandir ([E3,E1,E2],77) 65 Objetivo. Coste solución 65 horas.
Árbol Exploración con la heurística h2

Heurística: Se pueden repetir las No cogemos 20+25+5 tiene un

coste de 45+30+40>100 ([],0) 1
empresas y respetando coste, 20+25+15 tiene un coste de 60= 0+(20+25+15)
combinación mínima. Es más 45+30+20
complicado obtener h2.

([E1],15) ([E2],40) 2 ([E3],45)

70= 40+ (25+5) 71= 36+ (30+5) 60= 20+ (25+15)
No cogemos36+(25+5) tiene un coste de
40+40+40>100 3
No hay posibilidad de que se repitan
([E3,E1],57) ([E3,E2],75)
estados. Cómo las heurísticas
65=(20+30)+(15) 65=(20+25)+20
propuestas/pedidas deben ser
admisibles, y no aporta nada que sea 4
en grafo, hacemos la búsqueda en
([E3,E1,E2],77)
árbol. No hay lista de expandido, solo 65=(20+30+15)
frontera
Objetivo
Frontera
1) ([],0]60
2) ([E3],45)60 ([E1], 15)70 ([E2], 40)71
3) ([E3,E1],57) 65 ([E3,E2],75) 65 ([E1], 15)70 ([E2], 40)71
4) ([E3,E1,E2],77) 65 ([E3,E2],75) 65 ([E1], 15)70 ([E2], 40)71
Test objetivo al expander ([E3,E1,E2],97) 65 Objetivo
 Examen de Inteligencia Artificial.
16/01/ 2023

Duración total del examen: 3 horas

Ejercicio 2 [1 punto]

Suponiendo que la raíz del árbol es el jugador MAX, muestra los nodos
examinados usando la estrategia de poda α-β, y las ramas podadas asumiendo
recorrido de izquierda a derecha. Muestra los valores de α y β a lo largo del
recorrido en el árbol.

10 9 8 6

8 7 4 10 7 1 4 5 7 4 9

(a=-∞, ∞) (a=6, ∞)

6 Poda :
6
b(=6)=a(6)
(-∞, b= ∞) (6, b= ∞)
(6, b= 8) (6, b= 8)
(-∞, b= 10) (-∞, b= 8 8
(-∞, b= 9 8 6
10 9 6 Poda :
8
a(=10>8
10 9 8 6 (a=6, ∞) (a=8, ∞) (a=6, 8)
(a=6, 8) (a=6, 8) (a=6, 8)
(a=6, 8)
8 7 4 10 1
4
5
8 7 4 10 7 1 4 5 7 4 9
Ejercicio 3 [1 punto]
La siguiente figura representa un tablero de juego que contienen fichas colocadas
inicialmente como se muestra y representa el estado inicial. El jugador MAX tiene
las fichas marcadas como X y el MIN las fichas marcadas como 0.
X 0 0
0 X
X X 0
Estado Inicial

Los jugadores pueden mover sus fichas en cada turno de acuerdo con las
siguientes reglas:
• Contigua: Una ficha se puede desplazar a la casilla libre contigua,
derecha, izquierda, arriba o abajo.
• Salto: Una ficha puede saltar sobre otra ficha contraria (sólo una)
cambiando de signo/bando a la ficha contraria. No se puede saltar sobre
fichas propias

co X 0
0 a l hue
X sube 0 X
0 X X Xs
alt X X 0
X X 0 as
ob
re
Ejemplos de O X 0
movimientos posibles X X X
en el turno de MAX
X 0

El objetivo de cada jugador es tener el máximo número de sus fichas. Propón

una función de evaluación y utiliza el algoritmo MIN-MAX para averiguar cuál
debería ser el primer movimiento del jugador MAX desde la posición inicial.
Haz la exploración hasta el nivel 3 (dos jugadas de MAX y una de MIN). ¿Cuál
es el movimiento que debería escoger MAX?
 Examen de Inteligencia Artificial.
16/01/ 2023

Duración total del examen: 3 horas

Función de evaluación en nodos terminales

f: Número de fichas de MAX (X) – número de fichas de MIN (0)

Árbol de juego hasta nivel 3, y algoritmo MIN-MAX

MAX
-2 Max no tiene opción ganadora

MIN -2 -2

2 MAX -2 0 -2 2

1 -2 -2 0 -2 0 2

5-3=2 3-5=-2 3-5=-2 4-4=0 3-5=-2 4-4=0 5-3=2

Ejercicio 4 [1,5 puntos]

R R
A A
V V
Torre 1 Torre 2 Torre 3 Torre 1 Torre 2 Torre 3

Estado Inicial Estado Final

Se pide implementar en CLIPS el problema de las torres de Hanoi utilizando la
búsqueda de Coste Uniforme en grafo. En el problema planteado tenemos tres
discos con agujeros en el centro de colores rojo (R), azul(A) y verde(V) de
diámetros 10, 20 y 30 respectivamente. Hay tres postes en los que se pueden
colocar, con la restricción de que sólo se pueden colocar discos de menor
diámetro encima de un disco. Sólo se puede mover en cada movimiento un
disco de un poste a otro. Sólo se puede mover un disco si no tiene un disco
encima en el momento que se mueva. El estado inicial es el del dibujo de la
izquierda, con todos los discos en el poste 1, y el objetivo es colocar todos los
discos en el poste 3 de la derecha. Se te da parte del código realizado. Se pide
completar el siguiente programa CLIPS (completa sólo las reglas en los
recuadros):
LA SOLUCIÓN AL EJERCICIO ES LO COMPLETADO EN LOS CUADROS.

; -------------------------------------------------------------
; MODULO MAIN (COMPLETAR sólo las reglas en los recuadros:)
;-------------------------------------------------------------
(defmodule MAIN (export deftemplate nodo)
(export deftemplate disco))
(deftemplate MAIN::nodo
(multislot estado) (slot coste (default 0))
(slot clase (default abierto))(multislot camino))
(deftemplate MAIN::disco
(slot diametro)(slot color))
(deffacts MAIN::nodo-inicial (disco (color rojo) (diametro 10))
(disco (color azul) (diametro 20))
(disco (color verde)(diametro 30))
(nodo (estado TORRE rojo azul verde suelo TORRE suelo TORRE suelo)
(camino "TORRE rojo azul verde suelo TORRE suelo TORRE suelo")))

(defrule MAIN::pasa-el-mejor-a-cerrado-CU ;;; IMPLEMENTA CU

?nodo <- (nodo (coste ?c1) (clase abierto))
(not (nodo (clase abierto) (coste ?c2&:(< ?c2 ?c1))
)
=>
(modify ?nodo (clase cerrado))
(focus OPERADORES)
)
 Examen de Inteligencia Artificial.
16/01/ 2023

Duración total del examen: 3 horas

; MODULO OPERADORES (COMPLETAR sólo las reglas en los recuadros:)

;-------------------------------------------------------------
(defmodule OPERADORES (import MAIN deftemplate nodo)
(import MAIN deftemplate disco))

(defrule OPERADORES::DeTorreATorreSobreDiscoDcha
(nodo(estado $?p TORRE ?c1 $?t1 suelo $?m TORRE ?c2 $?t2 suelo $?f)
(camino $?movimientos)(coste ?coste)(clase cerrado))
(disco (color ?c1) (diametro ?d1))
(disco (color ?c2) (diametro ?d2&:(> ?d2 ?d1)))
=>
(assert (nodo
(estado $?p TORRE $?t1 suelo $?m TORRE ?c1 ?c2 $?t2 suelo $?f)
(camino ?movimientos (implode$
(create$ $?p TORRE $?t1 suelo $?m TORRE ?c1 ?c2 $?t2 suelo $?f)))
(coste (+ ?coste 1)))))

(defrule OPERADORES::DeTorreATorreSobreDiscoIzda ;;; IMPLEMENTA

(nodo(estado $?p TORRE ?c1 $?t1 suelo $?m TORRE ?c2 $?t2 suelo $?f)
(camino $?movimientos)(coste ?coste)(clase cerrado))
(disco (color ?c1) (diametro ?d1))
(disco (color ?c2) (diametro ?d2&:(> ?d1 ?d2)))
=>
(assert (nodo
(estado $?p TORRE ?c2 ?c1 $?t1 suelo $?m TORRE $?t2 suelo $?f)
(camino ?movimientos (implode$
(create$ $?p TORRE ?c2 ?c1 $?t1 suelo $?m TORRE $?t2 suelo $?f)))
(coste (+ ?coste 1)))))

(defrule OPERADORES::DeTorreATorreSobreSueloDcha ;;; IMPLEMENTA

(nodo (estado $?p TORRE ?c1 $?t1 suelo $?m TORRE suelo $?f)
(camino $?movimientos)(coste ?coste)(clase cerrado))
(disco (color ?c1) )
=>
(assert (nodo
(estado $?p TORRE $?t1 suelo $?m TORRE ?c1 suelo $?f)
(camino ?movimientos (implode$
(create$ $?p TORRE $?t1 suelo $?m TORRE ?c1 suelo $?f)))
(coste (+ ?coste 1)))))
(defrule OPERADORES::DeTorreATorreSobreSueloIzda
;;; NO HACE FALTA QUE LA IMPLEMENTES (SUPONEMOS QUE ESTÁ HECHA)
;;; NO APARECE EN ENUNCIADO, NI SE PIDE. SE DA POR COMPLETITUD PROG
(nodo (estado $?p TORRE suelo $?m TORRE ?c1 $?t1 suelo $?f)
(camino $?movimientos)(coste ?coste)(clase cerrado))
(disco (color ?c1) )
=>
(assert (nodo
(estado $?p TORRE ?c1 suelo $?m TORRE $?t1 suelo $?f)
(camino ?movimientos (implode$
(create$ ?p TORRE ?c1 suelo $?m TORRE $?t1 suelo $?f)))
(coste (+ ?coste 1)))))
;-------------------------------------------------------------
; MODULO RESTRICCIONES (COMPLETAR sólo las reglas en los recuadros:)
;-------------------------------------------------------------
(defmodule RESTRICCIONES (import MAIN deftemplate nodo))

; eliminamos nodos repetidos

(defrule RESTRICCIONES::repeticiones-de-nodo ;;; IMPLEMENTA
(declare (auto-focus TRUE))
?nodo1 <- (nodo (estado $?estado) (camino $?camino1))
?nodo2 <- (nodo (estado $?estado)
(camino $?camino2&:(>= (length$ ?camino1)
(length$ ?camino2))))
(test (neq ?nodo1 ?nodo2))
=>
(retract ?nodo1))
;-------------------------------------------------------------
; MODULO SOLUCION
;-------------------------------------------------------------
(defmodule SOLUCION (import MAIN deftemplate nodo))
(defrule SOLUCION::encuentra-solucion
(declare (auto-focus TRUE))
?nodo<- (nodo
(estado TORRE suelo TORRE suelo TORRE rojo azul verde suelo)
(camino $?movimientos)(clase cerrado))
=>
(retract ?nodo)
(assert (solucion ?movimientos)))
(defrule SOLUCION::escribe-solucion
(solucion $?movimientos)
=>
(printout t "La solucion tiene " (- (length$ ?movimientos) 1)
" pasos" crlf)
(loop-for-count (?i 1 (length$ ?movimientos))
(printout t (nth$ ?i $?movimientos) crlf)) (halt))