{"id":4867,"date":"2015-04-15T18:03:05","date_gmt":"2015-04-15T16:03:05","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=4867"},"modified":"2015-04-22T08:15:38","modified_gmt":"2015-04-22T06:15:38","slug":"i1m2014-el-patron-de-busqueda-por-primero-el-mejor-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2014-el-patron-de-busqueda-por-primero-el-mejor-en-haskell\/","title":{"rendered":"I1M2014: El patr\u00f3n de b\u00fasqueda por primero el mejor en Haskell"},"content":{"rendered":"<p>En la primera parte de la clase de hoy del curso <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-14\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos estudiado la t\u00e9cnica de resoluci\u00f3n de problemas mediante b\u00fasqueda por primero el mejor.<\/p>\n<p>La clase comenz\u00f3 analizando estudiando el problema del paseo:<\/p>\n<blockquote><p>\n  Una persona puede moverse en l\u00ednea recta dando cada vez un paso hacia la derecha o hacia la izquierda. Podemos representarlo mediante su posici\u00f3n X. El valor inicial de X es 0. El problema consiste en llegar a la posici\u00f3n -3.\n<\/p><\/blockquote>\n<p>Se represent\u00f3 el problema como espacio de estado y se comprob\u00f3 c\u00f3mo no se encuentra \u00f1a soluci\u00f3n mediante b\u00fasqueda en profundidad. Para resolverlo se introdujo una heur\u00edstica y el patr\u00f3n de b\u00fasqueda por primero el mejor. Finalmente, se aplic\u00f3 el patr\u00f3n de b\u00fasqueda para resolver el problema del 8 puzzle.<\/p>\n<p>Las transparencias usadas en la clase son las p\u00e1ginas 28-40 del <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-14\/temas\/tema-23t.pdf\">tema 23<\/a>:<br \/>\n<!--more--><br \/>\n<div class=\"jetpack-video-wrapper\"><iframe src='https:\/\/www.slideshare.net\/slideshow\/embed_code\/8057273' width='1290' height='1057' sandbox=\"allow-popups allow-scripts allow-same-origin allow-presentation\" allowfullscreen webkitallowfullscreen mozallowfullscreen><\/iframe><\/div><\/p>\n<p>El c\u00f3digo del problema del paseo es<\/p>\n<pre lang=\"haskell\">\nimport I1M.BusquedaEnEspaciosDeEstados\nimport I1M.BusquedaPrimeroElMejor\n\n-- ---------------------------------------------------------------------\n-- \u00a7 El problema del paseo                                            --\n-- ---------------------------------------------------------------------\n\n\ntype Posicion = Int\n\ninicial :: Posicion\ninicial = 0\n\nfinal :: Posicion\nfinal = -3\n\ndata Nodos = N [Posicion] deriving (Eq, Show)\n\n-- (sucesores n) es la lista de sucesores del nodo n. Por ejemplo,\n--    sucesores (N [0])     ==  [N [1,0],N [-1,0]]\n--    sucesores (N [1,0])   ==  [N [2,1,0]]\n--    sucesores (N [-1,0])  ==  [N [-2,-1,0]]\nsucesores :: Nodos -> [Nodos]\nsucesores (N (n@(p:ps))) = \n    [N (p+d:n) | d <- [1,-1], p+d `notElem` ps]\n\n-- (esFinal n) se verifica si n es un nodo final.\nesFinal :: Nodos -> Bool\nesFinal (N (p:_)) = p == final\n\n-- B\u00fasqueda en profundidad\n-- =======================\n\n-- (buscaEE_P) es la lista de las soluciones del problema del paseo por\n-- b\u00fasqueda en profundidad. \nbuscaEE_P = buscaEE sucesores\n                    esFinal        \n                    (N [inicial])\n\n-- Nota. Al buscar una soluci\u00f3n con\n--    ghci> head buscaEE_P\n--    C-c C-cInterrupted.\n-- hay que pararlo porque no la encuentra al meterse en una rama\n-- infinita. Se puede resolver cambiando el orden de los sucesores\n\nbuscaEE_P2 = buscaEE (reverse . sucesores)\n                     esFinal        \n                     (N [inicial])\n\n-- Ahora s\u00ed encuentra la soluci\u00f3n\n--    ghci> head buscaEE_P2\n--    N [-3,-2,-1,0]\n\n-- B\u00fasqueda por primero el mejor\n-- =============================\n\n-- (distancia x y) es la distancia entre las posiciones x e y. Por ejemplo,\n--    distancia    2    5  ==  3\n--    distancia (-2)    5  ==  7\n--    distancia    2 (-5)  ==  7\n--    distancia (-2) (-5)  ==  3\n--    distancia    5    2  ==  3\ndistancia :: Posicion -> Posicion -> Int\ndistancia x y = abs (x - y)\n\n-- (heuristica p) la distancia de p al estado final. Por ejemplo,\n--    heuristica inicial  ==  3\nheuristica :: Posicion  -> Int\nheuristica p = distancia p final\n\n-- Un nodo es menor o igual que otro si tiene una heur\u00edstica menor o\n-- igual. \ninstance Ord Nodos where \n    N (p1:_) <= N (p2:_) = heuristica p1 <= heuristica p2\n\n-- (buscaPM_P) es la lista de las soluciones del problema del paseo por\n-- b\u00fasqueda primero el mejor. Por ejemplo,\n--    head buscaPM_P  ==  N [-3,-2,-1,0]\nbuscaPM_P = buscaPM sucesores      \n                    esFinal        \n                    (N [inicial])\n<\/pre>\n<p>El c\u00f3digo del patr\u00f3n de b\u00fasqueda por primero el mejor es<\/p>\n<pre lang=\"haskell\">\nmodule BusquedaPrimeroElMejor (buscaPM)  where\n\n-- ---------------------------------------------------------------------\n-- Importaciones                                                      --\n-- ---------------------------------------------------------------------\n\n-- Nota: Hay que elegir una implementaci\u00f3n de las colas de prioridad.\nimport I1M.ColaDePrioridad\n-- import ColaDePrioridadConListas\n-- import ColaDePrioridadConMonticulos\n\n-- ---------------------------------------------------------------------\n-- B\u00fasqueda por primero el mejor                                      --\n-- ---------------------------------------------------------------------\n\n-- (buscaPM s o e) es la lista de soluciones del problema de espacio de\n-- estado definido por la funci\u00f3n sucesores (s), el objetivo (o) y el\n-- estado inicial (e), obtenidas buscando por primero el mejor.\nbuscaPM :: (Ord nodo) => \n           (nodo -> [nodo])   -- sucesores\n           -> (nodo -> Bool)  -- esFinal\n           -> nodo            -- nodo actual\n           -> [nodo]          -- soluci\u00f3n\nbuscaPM sucesores esFinal x = busca' (inserta x vacia)\n where\n   busca' c \n    | esVacia c = []\n    | esFinal (primero c)  \n        = (primero c):(busca' (resto c))\n    | otherwise            \n        = busca' (foldr inserta (resto c) (sucesores x))\n          where x = primero c\n<\/pre>\n<p>El c\u00f3digo del 8 puzzle es<\/p>\n<pre lang=\"haskell\">\nimport I1M.BusquedaPrimeroElMejor\nimport Data.Array\n\n-- ---------------------------------------------------------------------\n-- El problema del 8 puzzle                                           --\n-- ---------------------------------------------------------------------\n\n-- Para el 8-puzzle se usa un caj\u00f3n cuadrado en el que hay situados 8 bloques\n-- cuadrados.  El cuadrado restante est\u00e1 sin rellenar. Cada bloque tiene un\n-- n\u00famero. Un bloque adyacente al hueco puede deslizarse hacia \u00e9l. El juego\n-- consiste en transformar la posici\u00f3n inicial en la posici\u00f3n final mediante\n-- el deslizamiento de los bloques.  En particular, consideramos el estado\n-- inicial y final siguientes:\n--\n--      +---+---+---+                   +---+---+---+\n--      | 2 | 6 | 3 |                   | 1 | 2 | 3 | \n--      +---+---+---+                   +---+---+---+ \n--      | 5 |   | 4 |                   | 8 |   | 4 | \n--      +---+---+---+                   +---+---+---+ \n--      | 1 | 7 | 8 |                   | 7 | 6 | 5 | \n--      +---+---+---+                   +---+---+---+ \n--                      \n--      Estado inicial                  Estado final\n\n-- Una posici\u00f3n es un par de enteros.\ntype Posicion = (Int,Int)\n\n-- Un tablero es un vector de posiciones, en el que el \u00edndice indica el\n-- elemento que ocupa la posici\u00f3n.\ntype Tablero  = Array Int Posicion\n\n-- inicial8P es el estado inicial del 8 puzzle. En el ejemplo es\n--      +---+---+---+\n--      | 2 | 6 | 3 | \n--      +---+---+---+ \n--      | 5 |   | 4 | \n--      +---+---+---+ \n--      | 1 | 7 | 8 | \n--      +---+---+---+ \ninicial8P :: Tablero \ninicial8P = array (0,8) [(2,(1,3)),(6,(2,3)),(3,(3,3)),\n                         (5,(1,2)),(0,(2,2)),(4,(3,2)),\n                         (1,(1,1)),(7,(2,1)),(8,(3,1))]\n\n-- final8P es el estado final del 8 puzzle. En el ejemplo es\n--      +---+---+---+\n--      | 1 | 2 | 3 | \n--      +---+---+---+ \n--      | 8 |   | 4 | \n--      +---+---+---+ \n--      | 7 | 6 | 5 | \n--      +---+---+---+ \nfinal8P :: Tablero\nfinal8P = array (0,8) [(1,(1,3)),(2,(2,3)),(3,(3,3)),\n                       (8,(1,2)),(0,(2,2)),(4,(3,2)),\n                       (7,(1,1)),(6,(2,1)),(5,(3,1))]\n\n-- (distancia p1 p2) es la distancia Manhatan entre las posiciones p1 y\n-- p2. Por ejemplo,\n--    distancia (2,7) (4,1)  ==  8\ndistancia :: Posicion -> Posicion -> Int\ndistancia (x1,y1) (x2,y2) = abs (x1-x2) + abs (y1-y2)\n\n-- (adyacente p1 p2) se verifica si las posiciones p1 y p2 son\n-- adyacentes. Por ejemplo,\n--    adyacente (3,2) (3,1)  ==  True\n--    adyacente (3,2) (1,2)  ==  False\nadyacente :: Posicion -> Posicion -> Bool\nadyacente p1 p2 = distancia p1 p2 == 1\n\n-- (todosMovimientos t) es la lista de los tableros obtenidos\n-- aplic\u00e1ndole al tablero t todos los posibles movimientos; es decir,\n-- intercambiando la posici\u00f3n del hueco con sus adyacentes. Por ejemplo, \n--    ghci> inicial8P\n--    array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                 (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]\n--    ghci> todosMovimientos inicial8P\n--    [array (0,8) [(0,(3,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(2,2)),\n--                  (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--     array (0,8) [(0,(1,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                  (5,(2,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--     array (0,8) [(0,(2,3)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                  (5,(1,2)),(6,(2,2)),(7,(2,1)),(8,(3,1))],\n--     array (0,8) [(0,(2,1)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                  (5,(1,2)),(6,(2,3)),(7,(2,2)),(8,(3,1))]]\ntodosMovimientos :: Tablero -> [Tablero]\ntodosMovimientos t = \n    [t\/\/[(0,t!i),(i,t!0)] | i<-[1..8], adyacente (t!0) (t!i)] \n\n-- Los nodos del espacio de estados son listas de tableros [t_n,...,t_1]\n-- tal que t_i es un sucesor de t_(i-1).\ndata Tableros = Est [Tablero] deriving Show\n\n-- (sucesores8P e) es la lista de sucesores del estado e. Por ejemplo,\n--    ghci> sucesores8P (Est [inicial8P])\n--    [Est [array (0,8) [(0,(3,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(2,2)),\n--                       (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]],\n--    Est [array (0,8) [(0,(1,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(2,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--         array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]],\n--    Est [array (0,8) [(0,(2,3)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(1,2)),(6,(2,2)),(7,(2,1)),(8,(3,1))],\n--         array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]],\n--    Est [array (0,8) [(0,(2,1)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(1,2)),(6,(2,3)),(7,(2,2)),(8,(3,1))],\n--         array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                      (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]]]\nsucesores8P :: Tableros -> [Tableros]\nsucesores8P (Est(n@(t:ts))) = \n    [Est (t':n) | t' <- todosMovimientos t, t' `notElem` ts]\n\n-- (esFinal8P n) se verifica si n es un nodo final del 8 puzzle.\nesFinal8P :: Tableros -> Bool\nesFinal8P (Est (t:_)) = t == final8P\n\n-- Heur\u00edsticas\n-- ===========\n\n-- (heur1 t) es la suma de la distancia Manhatan desde la posici\u00f3n de\n-- cada objeto del tablero a su posici\u00f3n en el estado final. Por\n-- ejemplo,\n--    heur1 inicial8P  ==  12\nheur1 :: Tablero  -> Int\nheur1 t = \n    sum [distancia (t!i) (final8P!i) | i <- [0..8]]\n\n-- Dos estados se consideran iguales si tienen la misma heur\u00edstica.\ninstance Eq Tableros\n    where Est(t1:_) == Est(t2:_) = heur1 t1 == heur1 t2\n\n-- Un estado es menor o igual que otro si tiene una heur\u00edstica menor o\n-- igual. \ninstance Ord Tableros where \n    Est (t1:_) <= Est (t2:_) = heur1 t1 <= heur1 t2\n\n-- (buscaPM_8P) es la lista de las soluciones del 8 puzzle por b\u00fasqueda\n-- primero el mejor. Por ejemplo,\n--    ghci> head buscaPM_8P\n--    (Est [array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(2,1)),(7,(1,1)),(8,(1,2))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(2,2)),(7,(1,1)),(8,(1,2))],\n--          array (0,8) [(0,(1,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(2,2)),(7,(2,1)),(8,(1,2))],\n--          array (0,8) [(0,(1,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(2,2)),(7,(2,1)),(8,(1,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(1,2)),(7,(2,1)),(8,(1,1))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(3,1)),(6,(1,2)),(7,(2,2)),(8,(1,1))],\n--          array (0,8) [(0,(3,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(1,2)),(7,(2,2)),(8,(1,1))],\n--          array (0,8) [(0,(3,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(2,1)),(6,(1,2)),(7,(2,2)),(8,(1,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(2,1)),(6,(1,2)),(7,(3,2)),(8,(1,1))],\n--          array (0,8) [(0,(1,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(2,1)),(6,(2,2)),(7,(3,2)),(8,(1,1))],\n--          array (0,8) [(0,(1,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(2,1)),(6,(2,2)),(7,(3,2)),(8,(1,2))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(1,1)),(6,(2,2)),(7,(3,2)),(8,(1,2))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(1,1)),(6,(2,1)),(7,(3,2)),(8,(1,2))],\n--          array (0,8) [(0,(3,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(1,1)),(6,(2,1)),(7,(2,2)),(8,(1,2))],\n--          array (0,8) [(0,(3,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(1,1)),(6,(2,1)),(7,(2,2)),(8,(1,2))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(1,1)),(6,(3,1)),(7,(2,2)),(8,(1,2))],\n--          array (0,8) [(0,(1,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(3,1)),(7,(2,2)),(8,(1,2))],\n--          array (0,8) [(0,(1,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(3,1)),(7,(2,2)),(8,(1,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(3,1)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,2)),(6,(3,1)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(3,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,2)),(6,(2,1)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(3,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(2,2)),(6,(2,1)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(2,1)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(2,2)),(7,(1,2)),(8,(1,1))],\n--          array (0,8) [(0,(1,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(2,2)),(7,(1,2)),(8,(2,1))],\n--          array (0,8) [(0,(1,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(2,2)),(7,(1,1)),(8,(2,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(1,2)),(7,(1,1)),(8,(2,1))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,1)),\n--                       (5,(3,2)),(6,(1,2)),(7,(1,1)),(8,(2,2))],\n--          array (0,8) [(0,(3,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,1)),\n--                       (5,(3,2)),(6,(1,2)),(7,(1,1)),(8,(2,2))],\n--          array (0,8) [(0,(3,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,1)),\n--                       (5,(3,1)),(6,(1,2)),(7,(1,1)),(8,(2,2))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,1)),\n--                       (5,(3,1)),(6,(1,2)),(7,(1,1)),(8,(3,2))],\n--          array (0,8) [(0,(2,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,2)),\n--                       (5,(3,1)),(6,(1,2)),(7,(1,1)),(8,(3,2))],\n--          array (0,8) [(0,(3,1)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,2)),\n--                       (5,(2,1)),(6,(1,2)),(7,(1,1)),(8,(3,2))],\n--          array (0,8) [(0,(3,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(2,2)),\n--                       (5,(2,1)),(6,(1,2)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(1,2)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(1,2)),(1,(1,3)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(2,2)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(1,3)),(1,(1,2)),(2,(2,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(2,2)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,3)),(1,(1,2)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(2,2)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,2)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,1)),(6,(2,3)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,1)),(1,(1,2)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,2)),(6,(2,3)),(7,(1,1)),(8,(3,1))],\n--          array (0,8) [(0,(1,1)),(1,(1,2)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--          array (0,8) [(0,(1,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(2,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))],\n--          array (0,8) [(0,(2,2)),(1,(1,1)),(2,(1,3)),(3,(3,3)),(4,(3,2)),\n--                       (5,(1,2)),(6,(2,3)),(7,(2,1)),(8,(3,1))]],\n--     78)\nbuscaPM_8P = buscaPM sucesores8P      \n                     esFinal8P        \n                     (Est [inicial8P])\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la primera parte de la clase de hoy del curso Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos estudiado la t\u00e9cnica de resoluci\u00f3n de problemas mediante b\u00fasqueda por primero el mejor. La clase comenz\u00f3 analizando estudiando el problema del paseo: Una persona puede moverse en l\u00ednea recta dando cada vez un paso hacia la&#8230;<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[238],"tags":[244,305],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4867"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=4867"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4867\/revisions"}],"predecessor-version":[{"id":4869,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4867\/revisions\/4869"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=4867"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=4867"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=4867"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}