Haskell y Python – Página 3

El tipo abstracto de datos de las colas de prioridad

PorJosé A. Alonso 5-julio-20237-julio-2023

1. El tipo abstracto de datos de las colas de prioridad

Una cola de prioridad es una cola en la que cada elemento tiene asociada una prioridad. La operación de extracción siempre elige el elemento de menor prioridad.

Las operaciones que definen a tipo abstracto de datos (TAD) de las colas de prioridad (cuyos elementos son del tipo a) son las siguientes:

   vacia   :: Ord a => CPrioridad a
   inserta :: Ord a => a -> CPrioridad a -> CPrioridad a
   primero :: Ord a => CPrioridad a -> a
   resto   :: Ord a => CPrioridad a -> CPrioridad a
   esVacia :: Ord a => CPrioridad a -> Bool

vacia :: Ord a => CPrioridad a

inserta :: Ord a => a -> CPrioridad a -> CPrioridad a

primero :: Ord a => CPrioridad a -> a

resto :: Ord a => CPrioridad a -> CPrioridad a

esVacia :: Ord a => CPrioridad a -> Bool

tales que

vacia es la cola de prioridad vacía.
(inserta x c) añade el elemento x a la cola de prioridad c.
(primero c) es el primer elemento de la cola de prioridad c.
(resto c) es el resto de la cola de prioridad c.
(esVacia c) se verifica si la cola de prioridad c es vacía.

Las operaciones tienen que verificar las siguientes propiedades:

inserta x (inserta y c) == inserta y (inserta x c)
primero (inserta x vacia) == x
Si x <= y, entonces primero (inserta y (inserta x c)) == primero (inserta x c)
resto (inserta x vacia) == vacia
Si x <= y, entonces resto (inserta y (inserta x c)) == inserta y (resto (inserta x c))
esVacia vacia
not (esVacia (inserta x c))

2. Las colas de prioridad en Haskell

2.1. El tipo abstracto de datos de las colas de prioridad en Haskell

El TAD de las colas de prioridadd se encuentra en el módulo ColaDePrioridad.hs cuyo contenido es el siguiente:

module TAD.ColaDePrioridad
  (CPrioridad,
   vacia,   -- Ord a => CPrioridad a
   inserta, -- Ord a => a -> CPrioridad a -> CPrioridad a
   primero, -- Ord a => CPrioridad a -> a
   resto,   -- Ord a => CPrioridad a -> CPrioridad a
   esVacia, -- Ord a => CPrioridad a -> Bool
  ) where

import TAD.ColaDePrioridadConListas

module TAD.ColaDePrioridad

(CPrioridad,

vacia, -- Ord a => CPrioridad a

inserta, -- Ord a => a -> CPrioridad a -> CPrioridad a

primero, -- Ord a => CPrioridad a -> a

resto, -- Ord a => CPrioridad a -> CPrioridad a

esVacia, -- Ord a => CPrioridad a -> Bool

) where

import TAD.ColaDePrioridadConListas

Para usar el TAD hay que usar una implementación concreta. En principio,
solo considearemos una que usa las listas.

2.2. Implementación de las colas de prioridad mediante listas

La implementación se encuentra en el módulo ColaDePrioridadConListas.hs cuyo contenido es el siguiente:

{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.ColaDePrioridadConListas
  (CPrioridad,
   vacia,   -- Ord a => CPrioridad a
   inserta, -- Ord a => a -> CPrioridad a -> CPrioridad a
   primero, -- Ord a => CPrioridad a -> a
   resto,   -- Ord a => CPrioridad a -> CPrioridad a
   esVacia, -- Ord a => CPrioridad a -> Bool
  ) where

import Test.QuickCheck

-- Colas de prioridad mediante listas.
newtype CPrioridad a = CP [a]
  deriving Eq

-- (escribeColaDePrioridad c) es la cadena correspondiente a la cola de
-- prioridad c. Por ejemplo,
--    λ> escribeColaDePrioridad (inserta 5 (inserta 2 (inserta 3 vacia)))
--    "2 | 3 | 5"
escribeColaDePrioridad :: Show a => CPrioridad a -> String
escribeColaDePrioridad (CP [])     = "-"
escribeColaDePrioridad (CP [x])    = show x
escribeColaDePrioridad (CP (x:xs)) = show x ++ " | " ++ escribeColaDePrioridad (CP xs)

-- Procedimiento de escritura de colas de prioridad.
instance Show a => Show (CPrioridad a) where
  show = escribeColaDePrioridad

-- Ejemplo de cola de prioridad
--    λ> inserta 5 (inserta 2 (inserta 3 vacia))
--    2 | 3 | 5

-- vacia es la cola de prioridad vacía. Por ejemplo,
--    λ> vacia
--    CP []
vacia :: Ord a => CPrioridad a
vacia = CP []

-- (inserta x c) es la cola obtenida añadiendo el elemento x a la cola
-- de prioridad c. Por ejemplo,
--    λ> inserta 5 (foldr inserta vacia [3,1,7,2,9])
--    1 | 2 | 3 | 5 | 7 | 9
inserta :: Ord a => a -> CPrioridad a -> CPrioridad a
inserta x (CP q) = CP (ins x q)
  where ins y []                   = [y]
        ins y r@(e:r') | y < e     = y:r
                       | otherwise = e:ins y r'

-- (primero c) es el primer elemento de la cola de prioridad c. Por
-- ejemplo,
--    primero (foldr inserta vacia [3,1,7,2,9])  ==  1
primero :: Ord a => CPrioridad a -> a
primero (CP(x:_)) = x
primero _         = error "primero: cola de prioridad vacia"

-- (resto c) es la cola de prioridad obtenida eliminando el primer
-- elemento de la cola de prioridad c. Por ejemplo,
--    λ> resto (foldr inserta vacia [3,1,7,2,9])
--    2 | 3 | 7 | 9
resto :: Ord a => CPrioridad a -> CPrioridad a
resto (CP (_:xs)) = CP xs
resto _           = error "resto: cola de prioridad vacia"

-- (esVacia c) se verifica si la cola de prioridad c es vacía. Por
-- ejemplo,
--    esVacia (foldr inserta vacia [3,1,7,2,9]) ==  False
--    esVacia vacia                             ==  True
esVacia :: Ord a => CPrioridad a -> Bool
esVacia (CP xs) = null xs

-- Generador de colas de prioridad
-- ===============================

-- genCPrioridad es un generador de colas de enteros. Por ejemplo,
--    λ> sample genCPrioridad
--    -
--    0 | 0
--    4
--    -4 | -3 | 6 | 6
--    -7 | -6 | -2 | 0
--    -10 | -10 | -5 | 1 | 4 | 6 | 6 | 9 | 10
--    -
--    -13 | -11 | -9 | -5 | -2 | -1 | 0 | 1 | 2 | 2 | 13 | 14
--    -15 | -13 | -13 | -5 | -3 | -1 | 3 | 5 | 7 | 9 | 9 | 14 | 16
--    -
--    -17 | -15 | -14 | -5 | -2 | 1 | 1 | 2 | 5 | 7
genCPrioridad :: (Arbitrary a, Num a, Ord a) =>  Gen (CPrioridad a)
genCPrioridad = do
  xs <- listOf arbitrary
  return (foldr inserta vacia xs)

-- El tipo cola de prioridad es una instancia del arbitrario.
instance (Arbitrary a, Num a, Ord a) => Arbitrary (CPrioridad a) where
  arbitrary = genCPrioridad

-- Propiedades de las colas de prioridad
-- =====================================

-- Propiedad. Si se añade dos elementos a una cola de prioridad se
-- obtiene la misma cola de prioridad idependientemente del orden en
-- que se añadan los elementos.
prop_inserta_conmuta :: Int -> Int -> CPrioridad Int -> Bool
prop_inserta_conmuta x y c =
  inserta x (inserta y c) == inserta y (inserta x c)

-- Comprobación.
--    λ> quickCheck prop_inserta_conmuta
--    +++ OK, passed 100 tests.

-- Propiedad. La cabeza de la cola de prioridad obtenida añadiendo un
-- elemento x a la cola de prioridad vacía es x.
prop_primero_inserta_vacia :: Int -> CPrioridad Int -> Bool
prop_primero_inserta_vacia x _ =
  primero (inserta x vacia) == x

-- Comprobación.
--    λ> quickCheck prop_primero_inserta_vacia
--    +++ OK, passed 100 tests.

-- Propiedad. El primer elemento de una cola de prioridad c no cambia
-- cuando se le añade un elemento mayor o igual que algún elemento de c.
prop_primero_inserta :: Int -> Int -> CPrioridad Int -> Property
prop_primero_inserta x y c =
  x <= y ==> primero (inserta y c') == primero c'
  where c' = inserta x c

-- Comprobación.
--    λ> quickCheck prop_primero_inserta
--    +++ OK, passed 100 tests.

-- Propiedad. El resto de añadir un elemento a la cola de prioridad
-- vacía es la cola vacía.
prop_resto_inserta_vacia :: Int -> Bool
prop_resto_inserta_vacia x =
  resto (inserta x vacia) == vacia

-- Comprobación.
--    λ> quickCheck prop_resto_inserta_vacia
--    +++ OK, passed 100 tests.

-- Propiedad. El resto de la cola de prioridad obtenida añadiendo un
-- elemento y a una cola c' (que tiene algún elemento menor o igual que
-- y) es la cola que se obtiene añadiendo y al resto de c'.
prop_resto_inserta :: Int -> Int -> CPrioridad Int -> Property
prop_resto_inserta x y c =
  x <= y ==> resto (inserta y c') == inserta y (resto c')
  where c' = inserta x c

-- Comprobación:
--    λ> quickCheck prop_resto_inserta
--    +++ OK, passed 100 tests.

-- Propiedad. vacia es una cola vacía.
prop_vacia_es_vacia :: Bool
prop_vacia_es_vacia = esVacia (vacia :: CPrioridad Int)

-- Comprobación.
--    λ> quickCheck prop_vacia_es_vacia
--    +++ OK, passed 100 tests.

-- Propiedad. Si se añade un elemento a una cola de prioridad se obtiene
-- una cola no vacía.
prop_inserta_no_es_vacia :: Int -> CPrioridad Int -> Bool
prop_inserta_no_es_vacia x c =
  not (esVacia (inserta x c))

-- Comprobación.
--    λ> quickCheck prop_inserta_no_es_vacia
--    +++ OK, passed 100 tests.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

{-# LANGUAGE FlexibleInstances #-}

{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module TAD.ColaDePrioridadConListas

(CPrioridad,

vacia, -- Ord a => CPrioridad a

inserta, -- Ord a => a -> CPrioridad a -> CPrioridad a

primero, -- Ord a => CPrioridad a -> a

resto, -- Ord a => CPrioridad a -> CPrioridad a

esVacia, -- Ord a => CPrioridad a -> Bool

) where

import Test.QuickCheck

-- Colas de prioridad mediante listas.

newtype CPrioridad a = CP [a]

deriving Eq

-- (escribeColaDePrioridad c) es la cadena correspondiente a la cola de

-- prioridad c. Por ejemplo,

-- λ> escribeColaDePrioridad (inserta 5 (inserta 2 (inserta 3 vacia)))

-- "2 | 3 | 5"

escribeColaDePrioridad :: Show a => CPrioridad a -> String

escribeColaDePrioridad (CP []) = "-"

escribeColaDePrioridad (CP [x]) = show x

escribeColaDePrioridad (CP (x:xs)) = show x ++ " | " ++ escribeColaDePrioridad (CP xs)

-- Procedimiento de escritura de colas de prioridad.

instance Show a => Show (CPrioridad a) where

show = escribeColaDePrioridad

-- Ejemplo de cola de prioridad

-- λ> inserta 5 (inserta 2 (inserta 3 vacia))

-- 2 | 3 | 5

-- vacia es la cola de prioridad vacía. Por ejemplo,

-- λ> vacia

-- CP []

vacia :: Ord a => CPrioridad a

vacia = CP []

-- (inserta x c) es la cola obtenida añadiendo el elemento x a la cola

-- de prioridad c. Por ejemplo,

-- λ> inserta 5 (foldr inserta vacia [3,1,7,2,9])

-- 1 | 2 | 3 | 5 | 7 | 9

inserta :: Ord a => a -> CPrioridad a -> CPrioridad a

inserta x (CP q) = CP (ins x q)

where ins y [] = [y]

ins y r@(e:r') | y < e = y:r

| otherwise = e:ins y r'

-- (primero c) es el primer elemento de la cola de prioridad c. Por

-- ejemplo,

-- primero (foldr inserta vacia [3,1,7,2,9]) == 1

primero :: Ord a => CPrioridad a -> a

primero (CP(x:_)) = x

primero _ = error "primero: cola de prioridad vacia"

-- (resto c) es la cola de prioridad obtenida eliminando el primer

-- elemento de la cola de prioridad c. Por ejemplo,

-- λ> resto (foldr inserta vacia [3,1,7,2,9])

-- 2 | 3 | 7 | 9

resto :: Ord a => CPrioridad a -> CPrioridad a

resto (CP (_:xs)) = CP xs

resto _ = error "resto: cola de prioridad vacia"

-- (esVacia c) se verifica si la cola de prioridad c es vacía. Por

-- ejemplo,

-- esVacia (foldr inserta vacia [3,1,7,2,9]) == False

-- esVacia vacia == True

esVacia :: Ord a => CPrioridad a -> Bool

esVacia (CP xs) = null xs

-- Generador de colas de prioridad

-- ===============================

-- genCPrioridad es un generador de colas de enteros. Por ejemplo,

-- λ> sample genCPrioridad

-- -

-- 0 | 0

-- 4

-- -4 | -3 | 6 | 6

-- -7 | -6 | -2 | 0

-- -10 | -10 | -5 | 1 | 4 | 6 | 6 | 9 | 10

-- -

-- -13 | -11 | -9 | -5 | -2 | -1 | 0 | 1 | 2 | 2 | 13 | 14

-- -15 | -13 | -13 | -5 | -3 | -1 | 3 | 5 | 7 | 9 | 9 | 14 | 16

-- -

-- -17 | -15 | -14 | -5 | -2 | 1 | 1 | 2 | 5 | 7

genCPrioridad :: (Arbitrary a, Num a, Ord a) => Gen (CPrioridad a)

genCPrioridad = do

xs <- listOf arbitrary

return (foldr inserta vacia xs)

-- El tipo cola de prioridad es una instancia del arbitrario.

instance (Arbitrary a, Num a, Ord a) => Arbitrary (CPrioridad a) where

arbitrary = genCPrioridad

-- Propiedades de las colas de prioridad

-- =====================================

-- Propiedad. Si se añade dos elementos a una cola de prioridad se

-- obtiene la misma cola de prioridad idependientemente del orden en

-- que se añadan los elementos.

prop_inserta_conmuta :: Int -> Int -> CPrioridad Int -> Bool

prop_inserta_conmuta x y c =

inserta x (inserta y c) == inserta y (inserta x c)

-- Comprobación.

-- λ> quickCheck prop_inserta_conmuta

-- +++ OK, passed 100 tests.

-- Propiedad. La cabeza de la cola de prioridad obtenida añadiendo un

-- elemento x a la cola de prioridad vacía es x.

prop_primero_inserta_vacia :: Int -> CPrioridad Int -> Bool

prop_primero_inserta_vacia x _ =

primero (inserta x vacia) == x

-- Comprobación.

-- λ> quickCheck prop_primero_inserta_vacia

-- +++ OK, passed 100 tests.

-- Propiedad. El primer elemento de una cola de prioridad c no cambia

-- cuando se le añade un elemento mayor o igual que algún elemento de c.

prop_primero_inserta :: Int -> Int -> CPrioridad Int -> Property

prop_primero_inserta x y c =

x <= y ==> primero (inserta y c') == primero c'

where c' = inserta x c

-- Comprobación.

-- λ> quickCheck prop_primero_inserta

-- +++ OK, passed 100 tests.

-- Propiedad. El resto de añadir un elemento a la cola de prioridad

-- vacía es la cola vacía.

prop_resto_inserta_vacia :: Int -> Bool

prop_resto_inserta_vacia x =

resto (inserta x vacia) == vacia

-- Comprobación.

-- λ> quickCheck prop_resto_inserta_vacia

-- +++ OK, passed 100 tests.

-- Propiedad. El resto de la cola de prioridad obtenida añadiendo un

-- elemento y a una cola c' (que tiene algún elemento menor o igual que

-- y) es la cola que se obtiene añadiendo y al resto de c'.

prop_resto_inserta :: Int -> Int -> CPrioridad Int -> Property

prop_resto_inserta x y c =

x <= y ==> resto (inserta y c') == inserta y (resto c')

where c' = inserta x c

-- Comprobación:

-- λ> quickCheck prop_resto_inserta

-- +++ OK, passed 100 tests.

-- Propiedad. vacia es una cola vacía.

prop_vacia_es_vacia :: Bool

prop_vacia_es_vacia = esVacia (vacia :: CPrioridad Int)

-- Comprobación.

-- λ> quickCheck prop_vacia_es_vacia

-- +++ OK, passed 100 tests.

-- Propiedad. Si se añade un elemento a una cola de prioridad se obtiene

-- una cola no vacía.

prop_inserta_no_es_vacia :: Int -> CPrioridad Int -> Bool

prop_inserta_no_es_vacia x c =

not (esVacia (inserta x c))

-- Comprobación.

-- λ> quickCheck prop_inserta_no_es_vacia

-- +++ OK, passed 100 tests.

3. Las colas de prioridad en Python

3.1. El tipo abstracto de las colas de prioridad en Python

La implementación se encuentra en el módulo ColaDePrioridad.py cuyo contenido es el siguiente:

__all__ = [
   'CPrioridad',
   'vacia',
   'inserta',
   'primero',
   'resto',
   'esVacia',
    ]

from src.TAD.ColaDePrioridadConListas import (CPrioridad, esVacia, inserta,
                                              primero, resto, vacia)

__all__ = [

'CPrioridad',

'vacia',

'inserta',

'primero',

'resto',

'esVacia',

]

from src.TAD.ColaDePrioridadConListas import (CPrioridad, esVacia, inserta,

primero, resto, vacia)

Para usar el TAD hay que usar una implementación concreta. En principio, consideraremos solo una que usa las listas.

3.2. Implementación de las colas de prioridad mediante listas

La implementación se encuentra en el módulo ColaDePrioridadConListas.py en el que se define la clase CPrioridad con los siguientes métodos:

inserta(x) añade x a la cola.
primero() es el primero de la cola.
resto() elimina el primero de la cola.
esVacia() se verifica si la cola es vacía.

Por ejemplo,

   >>> c = CPrioridad()
   >>> c
   -
   >>> c.inserta(5)
   >>> c.inserta(2)
   >>> c.inserta(3)
   >>> c.inserta(4)
   >>> c
   2 | 3 | 4 | 5
   >>> c.primero()
   2
   >>> c.resto()
   >>> c
   3 | 4 | 5
   >>> c.esVacia()
   False
   >>> c = CPrioridad()
   >>> c.esVacia()
   True

>>> c = CPrioridad()

>>> c

>>> c.inserta(5)

>>> c.inserta(2)

>>> c.inserta(3)

>>> c.inserta(4)

>>> c

2 | 3 | 4 | 5

>>> c.primero()

>>> c.resto()

>>> c

3 | 4 | 5

>>> c.esVacia()

False

>>> c = CPrioridad()

>>> c.esVacia()

True

Además se definen las correspondientes funciones. Por ejemplo,

   >>> vacia()
   -
   >>> inserta(4, inserta(3, inserta(2, inserta(5, vacia()))))
   2 | 3 | 4 | 5
   >>> primero (inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))
   2
   >>> resto (inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))
   3 | 4 | 5
   >>> esVacia(inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))
   False
   >>> esVacia(vacia())
   True

>>> vacia()

>>> inserta(4, inserta(3, inserta(2, inserta(5, vacia()))))

2 | 3 | 4 | 5

>>> primero (inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))

>>> resto (inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))

3 | 4 | 5

>>> esVacia(inserta(4, inserta(3, inserta(2, inserta(5, vacia())))))

False

>>> esVacia(vacia())

True

Finalmente, se define un generador aleatorio de colas de prioridad y se comprueba que las colas de prioridad cumplen las propiedades de su especificación.

from __future__ import annotations

__all__ = [
   'CPrioridad',
   'vacia',
   'inserta',
   'primero',
   'resto',
   'esVacia',
]

from abc import abstractmethod
from copy import deepcopy
from dataclasses import dataclass, field
from typing import Generic, Protocol, TypeVar

from hypothesis import assume, given
from hypothesis import strategies as st


class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# Clase de las colas de prioridad mediante listas
# ===============================================

@dataclass
class CPrioridad(Generic[A]):
    _elementos: list[A] = field(default_factory=list)

    def __repr__(self) -> str:
        """
        Devuelve una cadena con los elementos de la cola separados por " | ".
        Si la cola está vacía, devuelve "-".
        """
        if not self._elementos:
            return '-'
        return ' | '.join(str(x) for x in self._elementos)

    def esVacia(self) -> bool:
        """
        Comprueba si la cola está vacía.

        Devuelve True si la cola está vacía, False en caso contrario.
        """
        return not self._elementos

    def inserta(self, x: A) -> None:
        """
        Inserta el elemento x en la cola de prioridad.
        """
        self._elementos.append(x)
        self._elementos.sort()

    def primero(self) -> A:
        """
        Devuelve el primer elemento de la cola.
        """
        return self._elementos[0]

    def resto(self) -> None:
        """
        Elimina el primer elemento de la cola
        """
        self._elementos.pop(0)

# Funciones del tipo de las listas
# ================================

def vacia() -> CPrioridad[A]:
    """
    Crea y devuelve una cola vacía de tipo A.
    """
    c: CPrioridad[A] = CPrioridad()
    return c

def inserta(x: A, c: CPrioridad[A]) -> CPrioridad[A]:
    """
    Inserta un elemento x en la cola c y devuelve una nueva cola con
    el elemento insertado.
    """
    _aux = deepcopy(c)
    _aux.inserta(x)
    return _aux

def esVacia(c: CPrioridad[A]) -> bool:
    """
    Devuelve True si la cola está vacía, False si no lo está.
    """
    return c.esVacia()

def primero(c: CPrioridad[A]) -> A:
    """
    Devuelve el primer elemento de la cola c.
    """
    return c.primero()

def resto(c: CPrioridad[A]) -> CPrioridad[A]:
    """
    Elimina el primer elemento de la cola c y devuelve una copia de la
    cola resultante.
    """
    _aux = deepcopy(c)
    _aux.resto()
    return _aux

# Generador de colas de prioridad
# ===============================

def colaAleatoria() -> st.SearchStrategy[CPrioridad[int]]:
    """
    Genera una estrategia de búsqueda para generar colas de enteros de
    forma aleatoria.

    Utiliza la librería Hypothesis para generar una lista de enteros y
    luego se convierte en una instancia de la clase cola.
    """
    return st.lists(st.integers()).map(CPrioridad)

# Comprobación de las propiedades de las colas
# ============================================

# Las propiedades son
@given(c=colaAleatoria(), x=st.integers(), y=st.integers())
def test_cola1(c: CPrioridad[int], x: int, y: int) -> None:
    assert inserta(x, inserta(y, c)) == inserta(y, inserta(x, c))
    assert primero(inserta(x, vacia())) == x
    assert resto(inserta(x, vacia())) == vacia()
    assert esVacia(vacia())
    assert not esVacia(inserta(x, c))

@given(c=colaAleatoria(), x=st.integers(), y=st.integers())
def test_cola2(c: CPrioridad[int], x: int, y: int) -> None:
    assume(not y < x)
    assert primero(inserta(y, (inserta(x, c)))) == \
        primero(inserta(x,c))
    assert resto(inserta(y, (inserta(x, c)))) == \
        inserta(y, resto(inserta(x, c)))

# La comprobación es
#    > poetry run pytest -q ColaDePrioridadConListas.py
#    2 passed in 0.54s

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

from __future__ import annotations

__all__ = [

'CPrioridad',

'vacia',

'inserta',

'primero',

'resto',

'esVacia',

]

from abc import abstractmethod

from copy import deepcopy

from dataclasses import dataclass, field

from typing import Generic, Protocol, TypeVar

from hypothesis import assume, given

from hypothesis import strategies as st

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# Clase de las colas de prioridad mediante listas

# ===============================================

@dataclass

class CPrioridad(Generic[A]):

_elementos: list[A] = field(default_factory=list)

def __repr__(self) -> str:

"""

Devuelve una cadena con los elementos de la cola separados por " | ".

Si la cola está vacía, devuelve "-".

"""

if not self._elementos:

return '-'

return ' | '.join(str(x) for x in self._elementos)

def esVacia(self) -> bool:

"""

Comprueba si la cola está vacía.

Devuelve True si la cola está vacía, False en caso contrario.

"""

return not self._elementos

def inserta(self, x: A) -> None:

"""

Inserta el elemento x en la cola de prioridad.

"""

self._elementos.append(x)

self._elementos.sort()

def primero(self) -> A:

"""

Devuelve el primer elemento de la cola.

"""

return self._elementos[0]

def resto(self) -> None:

"""

Elimina el primer elemento de la cola

"""

self._elementos.pop(0)

# Funciones del tipo de las listas

# ================================

def vacia() -> CPrioridad[A]:

"""

Crea y devuelve una cola vacía de tipo A.

"""

c: CPrioridad[A] = CPrioridad()

return c

def inserta(x: A, c: CPrioridad[A]) -> CPrioridad[A]:

"""

Inserta un elemento x en la cola c y devuelve una nueva cola con

el elemento insertado.

"""

_aux = deepcopy(c)

_aux.inserta(x)

return _aux

def esVacia(c: CPrioridad[A]) -> bool:

"""

Devuelve True si la cola está vacía, False si no lo está.

"""

return c.esVacia()

def primero(c: CPrioridad[A]) -> A:

"""

Devuelve el primer elemento de la cola c.

"""

return c.primero()

def resto(c: CPrioridad[A]) -> CPrioridad[A]:

"""

Elimina el primer elemento de la cola c y devuelve una copia de la

cola resultante.

"""

_aux = deepcopy(c)

_aux.resto()

return _aux

# Generador de colas de prioridad

# ===============================

def colaAleatoria() -> st.SearchStrategy[CPrioridad[int]]:

"""

Genera una estrategia de búsqueda para generar colas de enteros de

forma aleatoria.

Utiliza la librería Hypothesis para generar una lista de enteros y

luego se convierte en una instancia de la clase cola.

"""

return st.lists(st.integers()).map(CPrioridad)

# Comprobación de las propiedades de las colas

# ============================================

# Las propiedades son

@given(c=colaAleatoria(), x=st.integers(), y=st.integers())

def test_cola1(c: CPrioridad[int], x: int, y: int) -> None:

assert inserta(x, inserta(y, c)) == inserta(y, inserta(x, c))

assert primero(inserta(x, vacia())) == x

assert resto(inserta(x, vacia())) == vacia()

assert esVacia(vacia())

assert not esVacia(inserta(x, c))

@given(c=colaAleatoria(), x=st.integers(), y=st.integers())

def test_cola2(c: CPrioridad[int], x: int, y: int) -> None:

assume(not y < x)

assert primero(inserta(y, (inserta(x, c)))) == \

primero(inserta(x,c))

assert resto(inserta(y, (inserta(x, c)))) == \

inserta(y, resto(inserta(x, c)))

# La comprobación es

# > poetry run pytest -q ColaDePrioridadConListas.py

# 2 passed in 0.54s

El problema de la mochila (mediante espacio de estados)

PorJosé A. Alonso 4-julio-20231-julio-2023

Se tiene una mochila de capacidad de peso p y una lista de n para colocar en la mochila. Cada objeto i tiene un peso w(i) y un valor v(i). Considerando la posibilidad de colocar el mismo objeto varias veces en la mochila, el problema consiste en determinar la forma de colocar los objetos en la mochila sin sobrepasar la capacidad de la mochila colocando el máximo valor posible.

Para solucionar el problema se definen los siguientes tipos:

Una solución del problema de la mochila es una lista de objetos.

     type SolMoch = [Objeto]

1	type SolMoch = [Objeto]

Los objetos son pares formado por un peso y un valor

     type Objeto = (Peso,Valor)

1	type Objeto = (Peso,Valor)

Los pesos son número enteros

     type Peso = Int

1	type Peso = Int

Los valores son números reales.

     type Valor = Float

1	type Valor = Float

Los estados del problema de la mochila son 5-tupla de la (v,p,l,o,s) donde v es el valor de los objetos colocados, p es el peso de los objetos colocados, l es el límite de la capacidad de la mochila, o es la lista de los objetos colocados (ordenados de forma creciente según sus pesos) y s es la solución parcial.

     type NodoMoch = (Valor,Peso,Peso,[Objeto],SolMoch)

1	type NodoMoch = (Valor,Peso,Peso,[Objeto],SolMoch)

Usando el procedimiento de búsqueda en profundidad, definir la función

   mochila :: [Objeto] -> Peso -> (SolMoch,Valor)

1	mochila :: [Objeto] -> Peso -> (SolMoch,Valor)

tal que mochila os l es la solución del problema de la mochila para la lista de objetos os y el límite de capacidad l. Por ejemplo,

   > mochila [(2,3),(3,5),(4,6),(5,10)] 8
   ([(5,10.0),(3,5.0)],15.0)
   > mochila [(2,3),(3,5),(5,6)] 10
   ([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)
   > mochila [(8,15),(15,10),(3,6),(6,13),(2,4),(4,8),(5,6),(7,7)] 35
   ([(6,13.0),(6,13.0),(6,13.0),(6,13.0),(6,13.0),(3,6.0),(2,4.0)],75.0)
   > mochila [(2,2.8),(3,4.4),(5,6.1)] 10
   ([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)

> mochila [(2,3),(3,5),(4,6),(5,10)] 8

([(5,10.0),(3,5.0)],15.0)

> mochila [(2,3),(3,5),(5,6)] 10

([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)

> mochila [(8,15),(15,10),(3,6),(6,13),(2,4),(4,8),(5,6),(7,7)] 35

([(6,13.0),(6,13.0),(6,13.0),(6,13.0),(6,13.0),(3,6.0),(2,4.0)],75.0)

> mochila [(2,2.8),(3,4.4),(5,6.1)] 10

([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module BEE_Mochila where

import BusquedaEnProfundidad (buscaProfundidad)
import Data.List (sort)
import Test.Hspec (Spec, hspec, it, shouldBe)

type Peso     = Int
type Valor    = Float
type Objeto   = (Peso,Valor)
type SolMoch  = [Objeto]
type NodoMoch = (Valor,Peso,Peso,[Objeto],SolMoch)

mochila :: [Objeto] -> Peso -> (SolMoch,Valor)
mochila os l = (sol,v)
  where
    (v,_,_,_,sol) =
      maximum (buscaProfundidad sucesoresMoch
                                esObjetivoMoch
                                (inicial os l))

-- (inicial os l) es el estado inicial del problema de la mochila
-- para la lista de objetos os y el límite de capacidad l
inicial :: [Objeto] -> Peso -> NodoMoch
inicial os l =
  (0,0,l,sort os,[])

-- (sucesoresMoch e) es la lista de los sucesores del estado e en el
-- problema de la mochila para la lista de objetos os y el límite de
-- capacidad l.
sucesoresMoch :: NodoMoch -> [NodoMoch]
sucesoresMoch (v,p,l,os,solp) =
  [( v+v',
     p+p',
     l,
     [o | o@(p'',_) <- os, p''>=p'],
     (p',v'):solp )
  | (p',v') <- os,
    p+p' <= l]

-- (esObjetivoMoch e) se verifica si e es un estado final el problema de
-- la mochila para la lista de objetos os y el límite de capacidad l .
esObjetivoMoch :: NodoMoch -> Bool
esObjetivoMoch (_,p,l,(p',_):_,_) = p+p'>l

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    mochila [(2,3),(3,5),(4,6),(5,10)] 8
    `shouldBe` ([(5,10.0),(3,5.0)],15.0)
  it "e2" $
    mochila [(2,3),(3,5),(5,6)] 10
    `shouldBe` ([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)
  it "e3" $
    mochila [(8,15),(15,10),(3,6),(6,13),(2,4),(4,8),(5,6),(7,7)] 35
    `shouldBe` ([(6,13.0),(6,13.0),(6,13.0),(6,13.0),(6,13.0),(3,6.0),(2,4.0)],75.0)
  it "e4" $
    mochila [(2,2.8),(3,4.4),(5,6.1)] 10
    `shouldBe` ([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--
--    Finished in 0.0424 seconds
--    4 examples, 0 failures

module BEE_Mochila where

import BusquedaEnProfundidad (buscaProfundidad)

import Data.List (sort)

import Test.Hspec (Spec, hspec, it, shouldBe)

type Peso = Int

type Valor = Float

type Objeto = (Peso,Valor)

type SolMoch = [Objeto]

type NodoMoch = (Valor,Peso,Peso,[Objeto],SolMoch)

mochila :: [Objeto] -> Peso -> (SolMoch,Valor)

mochila os l = (sol,v)

where

(v,_,_,_,sol) =

maximum (buscaProfundidad sucesoresMoch

esObjetivoMoch

(inicial os l))

-- (inicial os l) es el estado inicial del problema de la mochila

-- para la lista de objetos os y el límite de capacidad l

inicial :: [Objeto] -> Peso -> NodoMoch

inicial os l =

(0,0,l,sort os,[])

-- (sucesoresMoch e) es la lista de los sucesores del estado e en el

-- problema de la mochila para la lista de objetos os y el límite de

-- capacidad l.

sucesoresMoch :: NodoMoch -> [NodoMoch]

sucesoresMoch (v,p,l,os,solp) =

[( v+v',

p+p',

[o | o@(p'',_) <- os, p''>=p'],

(p',v'):solp )

| (p',v') <- os,

p+p' <= l]

-- (esObjetivoMoch e) se verifica si e es un estado final el problema de

-- la mochila para la lista de objetos os y el límite de capacidad l .

esObjetivoMoch :: NodoMoch -> Bool

esObjetivoMoch (_,p,l,(p',_):_,_) = p+p'>l

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

mochila [(2,3),(3,5),(4,6),(5,10)] 8

`shouldBe` ([(5,10.0),(3,5.0)],15.0)

it "e2" $

mochila [(2,3),(3,5),(5,6)] 10

`shouldBe` ([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)

it "e3" $

mochila [(8,15),(15,10),(3,6),(6,13),(2,4),(4,8),(5,6),(7,7)] 35

`shouldBe` ([(6,13.0),(6,13.0),(6,13.0),(6,13.0),(6,13.0),(3,6.0),(2,4.0)],75.0)

it "e4" $

mochila [(2,2.8),(3,4.4),(5,6.1)] 10

`shouldBe` ([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- Finished in 0.0424 seconds

-- 4 examples, 0 failures

Soluciones en Python

from src.BusquedaEnProfundidad import buscaProfundidad

Peso = int
Valor = float
Objeto = tuple[Peso, Valor]
SolMoch = list[Objeto]
NodoMoch = tuple[Valor, Peso, Peso, list[Objeto], SolMoch]

# inicial(os, l) es el estado inicial del problema de la mochila
# para la lista de objetos os y el límite de capacidad l
def inicial(os: list[Objeto], l: Peso) -> NodoMoch:
    return (0,0,l,sorted(os),[])

# sucesoresMoch(e) es la lista de los sucesores del estado e en el
# problema de la mochila para la lista de objetos os y el límite de
# capacidad l.
def sucesoresMoch(n: NodoMoch) -> list[NodoMoch]:
    (v,p,l,os,solp) = n
    return [( v+v1,
              p+p1,
              l,
              [(p2,v2) for (p2,v2) in os if p2 >= p1],
              [(p1,v1)] + solp )
            for (p1,v1) in os if p + p1 <= l]

# esObjetivoMoch(e) se verifica si e es un estado final el problema de
# la mochila para la lista de objetos os y el límite de capacidad l .
def esObjetivoMoch(e: NodoMoch) -> bool:
    (_, p, l, os, _) = e
    (p_, _) = os[0]
    return p + p_ > l

def mochila(os: list[Objeto], l: Peso) -> tuple[SolMoch, Valor]:
    (v,_,_,_,sol) = max(buscaProfundidad(sucesoresMoch,
                                         esObjetivoMoch,
                                         inicial(os, l)))
    return (sol, v)

# Verificación
# ============

def test_Mochila() -> None:
    assert mochila([(2,3),(3,5),(4,6),(5,10)], 8) == \
        ([(5,10.0),(3,5.0)],15.0)
    assert mochila([(2,3),(3,5),(5,6)], 10) == \
        ([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)
    assert mochila([(2,2.8),(3,4.4),(5,6.1)], 10) == \
        ([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)
    print("Verificado")

# La verificación es
#    >>> test_Mochila()
#    Verificado

from src.BusquedaEnProfundidad import buscaProfundidad

Peso = int

Valor = float

Objeto = tuple[Peso, Valor]

SolMoch = list[Objeto]

NodoMoch = tuple[Valor, Peso, Peso, list[Objeto], SolMoch]

# inicial(os, l) es el estado inicial del problema de la mochila

# para la lista de objetos os y el límite de capacidad l

def inicial(os: list[Objeto], l: Peso) -> NodoMoch:

return (0,0,l,sorted(os),[])

# sucesoresMoch(e) es la lista de los sucesores del estado e en el

# problema de la mochila para la lista de objetos os y el límite de

# capacidad l.

def sucesoresMoch(n: NodoMoch) -> list[NodoMoch]:

(v,p,l,os,solp) = n

return [( v+v1,

p+p1,

[(p2,v2) for (p2,v2) in os if p2 >= p1],

[(p1,v1)] + solp )

for (p1,v1) in os if p + p1 <= l]

# esObjetivoMoch(e) se verifica si e es un estado final el problema de

# la mochila para la lista de objetos os y el límite de capacidad l .

def esObjetivoMoch(e: NodoMoch) -> bool:

(_, p, l, os, _) = e

(p_, _) = os[0]

return p + p_ > l

def mochila(os: list[Objeto], l: Peso) -> tuple[SolMoch, Valor]:

(v,_,_,_,sol) = max(buscaProfundidad(sucesoresMoch,

esObjetivoMoch,

inicial(os, l)))

return (sol, v)

# Verificación

# ============

def test_Mochila() -> None:

assert mochila([(2,3),(3,5),(4,6),(5,10)], 8) == \

([(5,10.0),(3,5.0)],15.0)

assert mochila([(2,3),(3,5),(5,6)], 10) == \

([(3,5.0),(3,5.0),(2,3.0),(2,3.0)],16.0)

assert mochila([(2,2.8),(3,4.4),(5,6.1)], 10) == \

([(3,4.4),(3,4.4),(2,2.8),(2,2.8)],14.4)

print("Verificado")

# La verificación es

# >>> test_Mochila()

# Verificado

El problema de las n reinas (mediante búsqueda por anchura en espacios de estados)

PorJosé A. Alonso 3-julio-202328-junio-2023

El problema de las n reinas consiste en colocar n reinas en un tablero cuadrado de dimensiones n por n de forma que no se encuentren más de una en la misma línea: horizontal, vertical o diagonal.

Las posiciones de las reinas en el tablero se representan por su columna y su fila.

   type Columna = Int
   type Fila    = Int

1 2	type Columna = Int type Fila = Int

Una solución del problema de las n reinas es una lista de posiciones.

   type SolNR = [(Columna,Fila)]

1	type SolNR = [(Columna,Fila)]

Usando el procedimiento de búsqueda en anchura, definir las funciones

   solucionesNR      :: Columna -> [SolNR]
   primeraSolucionNR :: Columna -> SolNR
   nSolucionesNR     :: Columna -> Int

solucionesNR :: Columna -> [SolNR]

primeraSolucionNR :: Columna -> SolNR

nSolucionesNR :: Columna -> Int

tales que

solucionesNR n es la lista de las soluciones del problema de las n reinas, por búsqueda de espacio de estados en anchura. Por ejemplo,

     take 3 (solucionesNR 8)
     [[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],
      [(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],
      [(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]

take 3 (solucionesNR 8)

[[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],

[(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],

[(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]

primeraSolucionNR n es la primera solución del problema de las n reinas, por búsqueda en espacio de estados por anchura. Por ejemplo,

     λ> primeraSolucionNR 8
     [(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)]

1 2	λ> primeraSolucionNR 8 [(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)]

nSolucionesNR n es el número de soluciones del problema de las n reinas, por búsqueda en espacio de estados. Por ejemplo,

     nSolucionesNR 8  ==  92

1	nSolucionesNR 8 == 92

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module BEE_Reinas_Anchura where

import BusquedaEnAnchura (buscaAnchura)
import Test.Hspec (Spec, hspec, it, shouldBe)

type Columna = Int
type Fila    = Int
type SolNR = [(Columna,Fila)]

-- Los nodos del problema de las n reinas son ternas formadas por la
-- columna de la última reina colocada, el número de columnas del
-- tablero y la solución parcial de las reinas colocadas anteriormente.
type NodoNR = (Columna,Columna,SolNR)

solucionesNR :: Columna -> [SolNR]
solucionesNR n =
  map estado (buscaAnchura sucesoresNR esFinalNR (1,n,[]))
  where
    estado (_,_,e) = e

primeraSolucionNR :: Columna -> SolNR
primeraSolucionNR =
  head . solucionesNR

nSolucionesNR :: Columna -> Int
nSolucionesNR =
  length . solucionesNR

-- (valida sp p) se verifica si la posición p es válida respecto de la
-- solución parcial sp; es decir, la reina en la posición p no amenaza a
-- ninguna de las reinas de la sp (se supone que están en distintas
-- columnas). Por ejemplo,
--    valida [(1,1)] (2,2)  ==  False
--    valida [(1,1)] (2,3)  ==  True
valida :: SolNR -> (Columna,Fila) -> Bool
valida solp (c,r) = and [test s | s <- solp]
  where test (c',r') = c'+r'/=c+r && c'-r'/=c-r && r'/=r

-- (sucesoresNR e) es la lista de los sucesores del estado e en el
-- problema de las n reinas. Por ejemplo,
--    λ> sucesoresNR (1,4,[])
--    [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]
sucesoresNR :: NodoNR -> [NodoNR]
sucesoresNR (c,n,solp) =
  [(c+1,n,solp ++ [(c,r)]) | r <- [1..n] , valida solp (c,r)]

-- (esFinalNR e) se verifica si e es un estado final del problema de las
-- n reinas.
esFinalNR :: NodoNR -> Bool
esFinalNR (c,n,_) = c > n

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    take 3 (solucionesNR 8) `shouldBe`
    [[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],
     [(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],
     [(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]
  it "e2" $
    nSolucionesNR 8 `shouldBe` 92

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.2116 seconds
--    2 examples, 0 failures

module BEE_Reinas_Anchura where

import BusquedaEnAnchura (buscaAnchura)

import Test.Hspec (Spec, hspec, it, shouldBe)

type Columna = Int

type Fila = Int

type SolNR = [(Columna,Fila)]

-- Los nodos del problema de las n reinas son ternas formadas por la

-- columna de la última reina colocada, el número de columnas del

-- tablero y la solución parcial de las reinas colocadas anteriormente.

type NodoNR = (Columna,Columna,SolNR)

solucionesNR :: Columna -> [SolNR]

solucionesNR n =

map estado (buscaAnchura sucesoresNR esFinalNR (1,n,[]))

where

estado (_,_,e) = e

primeraSolucionNR :: Columna -> SolNR

primeraSolucionNR =

head . solucionesNR

nSolucionesNR :: Columna -> Int

nSolucionesNR =

length . solucionesNR

-- (valida sp p) se verifica si la posición p es válida respecto de la

-- solución parcial sp; es decir, la reina en la posición p no amenaza a

-- ninguna de las reinas de la sp (se supone que están en distintas

-- columnas). Por ejemplo,

-- valida [(1,1)] (2,2) == False

-- valida [(1,1)] (2,3) == True

valida :: SolNR -> (Columna,Fila) -> Bool

valida solp (c,r) = and [test s | s <- solp]

where test (c',r') = c'+r'/=c+r && c'-r'/=c-r && r'/=r

-- (sucesoresNR e) es la lista de los sucesores del estado e en el

-- problema de las n reinas. Por ejemplo,

-- λ> sucesoresNR (1,4,[])

-- [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]

sucesoresNR :: NodoNR -> [NodoNR]

sucesoresNR (c,n,solp) =

[(c+1,n,solp ++ [(c,r)]) | r <- [1..n] , valida solp (c,r)]

-- (esFinalNR e) se verifica si e es un estado final del problema de las

-- n reinas.

esFinalNR :: NodoNR -> Bool

esFinalNR (c,n,_) = c > n

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

take 3 (solucionesNR 8) `shouldBe`

[[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],

[(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],

[(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]

it "e2" $

nSolucionesNR 8 `shouldBe` 92

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.2116 seconds

-- 2 examples, 0 failures

Soluciones en Python

from src.BusquedaEnAnchura import buscaAnchura

Columna = int
Fila = int
SolNR = list[tuple[Columna, Fila]]

# Los nodos del problema de las n reinas son ternas formadas por la
# columna de la última reina colocada, el número de columnas del
# tablero y la solución parcial de las reinas colocadas anteriormente.
NodoNR = tuple[Columna, Columna, SolNR]

# valida(sp, p) se verifica si la posición p es válida respecto de la
# solución parcial sp; es decir, la reina en la posición p no amenaza a
# ninguna de las reinas de la sp (se supone que están en distintas
# columnas). Por ejemplo,
#    valida([(1,1)], (2,2))  ==  False
#    valida([(1,1)], (2,3))  ==  True
def valida(sp: SolNR, p: tuple[Columna, Fila]) -> bool:
    c, r = p
    def test(s: tuple[Columna, Fila]) -> bool:
        c1, r1 = s
        return c1 + r1 != c + r and c1 - r1 != c - r and r1 != r

    return all(test(s) for s in sp)

# sucesoresNR(e) es la lista de los sucesores del estado e en el
# problema de las n reinas. Por ejemplo,
#    >>> sucesoresNR((1,4,[]))
#    [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]
def sucesoresNR (nd: NodoNR) -> list[NodoNR]:
    c,n,solp = nd
    return [(c+1,n,solp + [(c,r)]) for r in range(1, n+1) if valida(solp, (c,r))]

# esFinalNR(e) se verifica si e es un estado final del problema de las
# n reinas.
def esFinalNR(nd: NodoNR) -> bool:
    c, n, _ = nd
    return c > n

def solucionesNR(n: int) -> list[SolNR]:
    nInicial: NodoNR = (1,n,[])
    return [e for (_, _, e) in buscaAnchura(sucesoresNR,
                                            esFinalNR,
                                            nInicial)]

def primeraSolucionNR(n: int) -> SolNR:
    return solucionesNR(n)[0]

def nSolucionesNR(n: int) -> int:
    return len(solucionesNR(n))

# Verificación
# ============

def test_nReinas() -> None:
    assert solucionesNR(5)[:3] == \
        [[(1,1),(2,3),(3,5),(4,2),(5,4)],
         [(1,1),(2,4),(3,2),(4,5),(5,3)],
         [(1,2),(2,4),(3,1),(4,3),(5,5)]]
    assert nSolucionesNR(5) == 10
    print("Verificado")

# La verificación es
#    >>> test_nReinas()
#    Verificado

from src.BusquedaEnAnchura import buscaAnchura

Columna = int

Fila = int

SolNR = list[tuple[Columna, Fila]]

# Los nodos del problema de las n reinas son ternas formadas por la

# columna de la última reina colocada, el número de columnas del

# tablero y la solución parcial de las reinas colocadas anteriormente.

NodoNR = tuple[Columna, Columna, SolNR]

# valida(sp, p) se verifica si la posición p es válida respecto de la

# solución parcial sp; es decir, la reina en la posición p no amenaza a

# ninguna de las reinas de la sp (se supone que están en distintas

# columnas). Por ejemplo,

# valida([(1,1)], (2,2)) == False

# valida([(1,1)], (2,3)) == True

def valida(sp: SolNR, p: tuple[Columna, Fila]) -> bool:

c, r = p

def test(s: tuple[Columna, Fila]) -> bool:

c1, r1 = s

return c1 + r1 != c + r and c1 - r1 != c - r and r1 != r

return all(test(s) for s in sp)

# sucesoresNR(e) es la lista de los sucesores del estado e en el

# problema de las n reinas. Por ejemplo,

# >>> sucesoresNR((1,4,[]))

# [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]

def sucesoresNR (nd: NodoNR) -> list[NodoNR]:

c,n,solp = nd

return [(c+1,n,solp + [(c,r)]) for r in range(1, n+1) if valida(solp, (c,r))]

# esFinalNR(e) se verifica si e es un estado final del problema de las

# n reinas.

def esFinalNR(nd: NodoNR) -> bool:

c, n, _ = nd

return c > n

def solucionesNR(n: int) -> list[SolNR]:

nInicial: NodoNR = (1,n,[])

return [e for (_, _, e) in buscaAnchura(sucesoresNR,

esFinalNR,

nInicial)]

def primeraSolucionNR(n: int) -> SolNR:

return solucionesNR(n)[0]

def nSolucionesNR(n: int) -> int:

return len(solucionesNR(n))

# Verificación

# ============

def test_nReinas() -> None:

assert solucionesNR(5)[:3] == \

[[(1,1),(2,3),(3,5),(4,2),(5,4)],

[(1,1),(2,4),(3,2),(4,5),(5,3)],

[(1,2),(2,4),(3,1),(4,3),(5,5)]]

assert nSolucionesNR(5) == 10

print("Verificado")

# La verificación es

# >>> test_nReinas()

# Verificado

Búsqueda por anchura en espacios de estados

PorJosé A. Alonso 30-junio-202328-junio-2023

Las características de los problemas de espacios de estados son:

un conjunto de las posibles situaciones o nodos que constituye el espacio de estados (estos son las potenciales soluciones que se necesitan explorar),
un conjunto de movimientos de un nodo a otros nodos, llamados los sucesores del nodo,
un nodo inicial y
un nodo objetivo que es la solución.

Definir la función

   buscaAnchura :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)
                              -> nodo -> [nodo]

1 2	buscaAnchura :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool) -> nodo -> [nodo]

tal que buscaAnchura s o e es la lista de soluciones del problema de espacio de estado definido por la función sucesores s, el objetivo o y estado inicial e obtenidas mediante búsqueda en anchura.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module BusquedaEnAnchura (buscaAnchura) where

import TAD.Cola (esVacia, inserta, primero, resto, vacia)

buscaAnchura :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)
                               -> nodo -> [nodo]
buscaAnchura sucesores esFinal inicial =
  aux (inserta inicial vacia)
  where
    aux p
      | esVacia p        = []
      | esFinal (primero p) = primero p : aux (resto p)
      | otherwise        = aux (foldr
                                inserta
                                (resto p)
                                (sucesores (primero p)))

module BusquedaEnAnchura (buscaAnchura) where

import TAD.Cola (esVacia, inserta, primero, resto, vacia)

buscaAnchura :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)

-> nodo -> [nodo]

buscaAnchura sucesores esFinal inicial =

aux (inserta inicial vacia)

where

aux p

| esVacia p = []

| esFinal (primero p) = primero p : aux (resto p)

| otherwise = aux (foldr

inserta

(resto p)

(sucesores (primero p)))

Soluciones en Python

from functools import reduce
from sys import setrecursionlimit
from typing import Callable, TypeVar

from src.TAD.cola import Cola, esVacia, inserta, primero, resto, vacia

A = TypeVar('A')

setrecursionlimit(10**6)

def buscaAnchura(sucesores: Callable[[A], list[A]],
                  esFinal: Callable[[A], bool],
                  inicial: A) -> list[A]:
    def aux(p: Cola[A]) -> list[A]:
        if esVacia(p):
            return []
        if esFinal(primero(p)):
            return [primero(p)] + aux(resto(p))
        return aux(reduce(lambda x, y: inserta(y, x),
                          sucesores(primero(p)),
                          resto(p)))

    return aux (inserta(inicial, vacia()))

from functools import reduce

from sys import setrecursionlimit

from typing import Callable, TypeVar

from src.TAD.cola import Cola, esVacia, inserta, primero, resto, vacia

A = TypeVar('A')

setrecursionlimit(10**6)

def buscaAnchura(sucesores: Callable[[A], list[A]],

esFinal: Callable[[A], bool],

inicial: A) -> list[A]:

def aux(p: Cola[A]) -> list[A]:

if esVacia(p):

return []

if esFinal(primero(p)):

return [primero(p)] + aux(resto(p))

return aux(reduce(lambda x, y: inserta(y, x),

sucesores(primero(p)),

resto(p)))

return aux (inserta(inicial, vacia()))

El problema de las n reinas (mediante búsqueda por profundidad en espacios de estados)

PorJosé A. Alonso 29-junio-202328-junio-2023

El problema de las n reinas consiste en colocar n reinas en un tablero cuadrado de dimensiones n por n de forma que no se encuentren más de una en la misma línea: horizontal, vertical o diagonal.

Las posiciones de las reinas en el tablero se representan por su columna y su fila.

   type Columna = Int
   type Fila    = Int

1 2	type Columna = Int type Fila = Int

Una solución del problema de las n reinas es una lista de posiciones.

   type SolNR = [(Columna,Fila)]

1	type SolNR = [(Columna,Fila)]

Usando el procedimiento de búsqueda en profundidad, definir las funciones

   solucionesNR      :: Columna -> [SolNR]
   primeraSolucionNR :: Columna -> SolNR
   nSolucionesNR     :: Columna -> Int

solucionesNR :: Columna -> [SolNR]

primeraSolucionNR :: Columna -> SolNR

nSolucionesNR :: Columna -> Int

tales que

solucionesNR n es la lista de las soluciones del problema de las n reinas, por búsqueda de espacio de estados en profundidad. Por ejemplo,

     take 3 (solucionesNR 8)
     [[(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)],
      [(1,1),(2,6),(3,8),(4,3),(5,7),(6,4),(7,2),(8,5)],
      [(1,1),(2,7),(3,4),(4,6),(5,8),(6,2),(7,5),(8,3)]]

take 3 (solucionesNR 8)

[[(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)],

[(1,1),(2,6),(3,8),(4,3),(5,7),(6,4),(7,2),(8,5)],

[(1,1),(2,7),(3,4),(4,6),(5,8),(6,2),(7,5),(8,3)]]

primeraSolucionNR n es la primera solución del problema de las n reinas, por búsqueda en espacio de estados por profundidad. Por ejemplo,

     λ> primeraSolucionNR 8
     [(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)]

1 2	λ> primeraSolucionNR 8 [(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)]

nSolucionesNR n es el número de soluciones del problema de las n reinas, por búsqueda en espacio de estados. Por ejemplo,

     nSolucionesNR 8  ==  92

1	nSolucionesNR 8 == 92

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module BEE_Reinas_Profundidad where

import BusquedaEnProfundidad (buscaProfundidad)
import Test.Hspec (Spec, hspec, it, shouldBe)

type Columna = Int
type Fila    = Int
type SolNR = [(Columna,Fila)]

-- Los nodos del problema de las n reinas son ternas formadas por la
-- columna de la última reina colocada, el número de columnas del
-- tablero y la solución parcial de las reinas colocadas anteriormente.
type NodoNR = (Columna,Columna,SolNR)

solucionesNR :: Columna -> [SolNR]
solucionesNR n =
  map estado (buscaProfundidad sucesoresNR esFinalNR (1,n,[]))
  where
    estado (_,_,e) = e

primeraSolucionNR :: Columna -> SolNR
primeraSolucionNR =
  head . solucionesNR

nSolucionesNR :: Columna -> Int
nSolucionesNR =
  length . solucionesNR

-- (valida sp p) se verifica si la posición p es válida respecto de la
-- solución parcial sp; es decir, la reina en la posición p no amenaza a
-- ninguna de las reinas de la sp (se supone que están en distintas
-- columnas). Por ejemplo,
--    valida [(1,1)] (2,2)  ==  False
--    valida [(1,1)] (2,3)  ==  True
valida :: SolNR -> (Columna,Fila) -> Bool
valida solp (c,r) = and [test s | s <- solp]
  where test (c',r') = c'+r'/=c+r && c'-r'/=c-r && r'/=r

-- (sucesoresNR e) es la lista de los sucesores del estado e en el
-- problema de las n reinas. Por ejemplo,
--    λ> sucesoresNR (1,4,[])
--    [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]
sucesoresNR :: NodoNR -> [NodoNR]
sucesoresNR (c,n,solp) =
  [(c+1,n,solp ++ [(c,r)]) | r <- [1..n] , valida solp (c,r)]

-- (esFinalNR e) se verifica si e es un estado final del problema de las
-- n reinas.
esFinalNR :: NodoNR -> Bool
esFinalNR (c,n,_) = c > n

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    take 3 (solucionesNR 8) `shouldBe`
    [[(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)],
     [(1,1),(2,6),(3,8),(4,3),(5,7),(6,4),(7,2),(8,5)],
     [(1,1),(2,7),(3,4),(4,6),(5,8),(6,2),(7,5),(8,3)]]
  it "e2" $
    nSolucionesNR 8 `shouldBe` 92

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.1173 seconds
--    2 examples, 0 failures

module BEE_Reinas_Profundidad where

import BusquedaEnProfundidad (buscaProfundidad)

import Test.Hspec (Spec, hspec, it, shouldBe)

type Columna = Int

type Fila = Int

type SolNR = [(Columna,Fila)]

-- Los nodos del problema de las n reinas son ternas formadas por la

-- columna de la última reina colocada, el número de columnas del

-- tablero y la solución parcial de las reinas colocadas anteriormente.

type NodoNR = (Columna,Columna,SolNR)

solucionesNR :: Columna -> [SolNR]

solucionesNR n =

map estado (buscaProfundidad sucesoresNR esFinalNR (1,n,[]))

where

estado (_,_,e) = e

primeraSolucionNR :: Columna -> SolNR

primeraSolucionNR =

head . solucionesNR

nSolucionesNR :: Columna -> Int

nSolucionesNR =

length . solucionesNR

-- (valida sp p) se verifica si la posición p es válida respecto de la

-- solución parcial sp; es decir, la reina en la posición p no amenaza a

-- ninguna de las reinas de la sp (se supone que están en distintas

-- columnas). Por ejemplo,

-- valida [(1,1)] (2,2) == False

-- valida [(1,1)] (2,3) == True

valida :: SolNR -> (Columna,Fila) -> Bool

valida solp (c,r) = and [test s | s <- solp]

where test (c',r') = c'+r'/=c+r && c'-r'/=c-r && r'/=r

-- (sucesoresNR e) es la lista de los sucesores del estado e en el

-- problema de las n reinas. Por ejemplo,

-- λ> sucesoresNR (1,4,[])

-- [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]

sucesoresNR :: NodoNR -> [NodoNR]

sucesoresNR (c,n,solp) =

[(c+1,n,solp ++ [(c,r)]) | r <- [1..n] , valida solp (c,r)]

-- (esFinalNR e) se verifica si e es un estado final del problema de las

-- n reinas.

esFinalNR :: NodoNR -> Bool

esFinalNR (c,n,_) = c > n

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

take 3 (solucionesNR 8) `shouldBe`

[[(1,1),(2,5),(3,8),(4,6),(5,3),(6,7),(7,2),(8,4)],

[(1,1),(2,6),(3,8),(4,3),(5,7),(6,4),(7,2),(8,5)],

[(1,1),(2,7),(3,4),(4,6),(5,8),(6,2),(7,5),(8,3)]]

it "e2" $

nSolucionesNR 8 `shouldBe` 92

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.1173 seconds

-- 2 examples, 0 failures

Soluciones en Python

from src.BusquedaEnProfundidad import buscaProfundidad

Columna = int
Fila = int
SolNR = list[tuple[Columna, Fila]]

# Los nodos del problema de las n reinas son ternas formadas por la
# columna de la última reina colocada, el número de columnas del
# tablero y la solución parcial de las reinas colocadas anteriormente.
NodoNR = tuple[Columna, Columna, SolNR]

# valida(sp, p) se verifica si la posición p es válida respecto de la
# solución parcial sp; es decir, la reina en la posición p no amenaza a
# ninguna de las reinas de la sp (se supone que están en distintas
# columnas). Por ejemplo,
#    valida([(1,1)], (2,2))  ==  False
#    valida([(1,1)], (2,3))  ==  True
def valida(sp: SolNR, p: tuple[Columna, Fila]) -> bool:
    c, r = p
    def test(s: tuple[Columna, Fila]) -> bool:
        c1, r1 = s
        return c1 + r1 != c + r and c1 - r1 != c - r and r1 != r

    return all(test(s) for s in sp)

# sucesoresNR(e) es la lista de los sucesores del estado e en el
# problema de las n reinas. Por ejemplo,
#    >>> sucesoresNR((1,4,[]))
#    [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]
def sucesoresNR (nd: NodoNR) -> list[NodoNR]:
    c,n,solp = nd
    return [(c+1,n,solp + [(c,r)]) for r in range(1, n+1) if valida(solp, (c,r))]

# esFinalNR(e) se verifica si e es un estado final del problema de las
# n reinas.
def esFinalNR(nd: NodoNR) -> bool:
    c, n, _ = nd
    return c > n

def solucionesNR(n: int) -> list[SolNR]:
    nInicial: NodoNR = (1,n,[])
    return [e for (_, _, e) in buscaProfundidad(sucesoresNR,
                                                esFinalNR,
                                                nInicial)]

def primeraSolucionNR(n: int) -> SolNR:
    return solucionesNR(n)[0]

def nSolucionesNR(n: int) -> int:
    return len(solucionesNR(n))

# Verificación
# ============

def test_nReinas() -> None:
    assert solucionesNR(8)[:3] == \
        [[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],
         [(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],
         [(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]
    assert nSolucionesNR(8) == 92
    print("Verificado")

# La verificación es
#    >>> test_nReinas()
#    Verificado

from src.BusquedaEnProfundidad import buscaProfundidad

Columna = int

Fila = int

SolNR = list[tuple[Columna, Fila]]

# Los nodos del problema de las n reinas son ternas formadas por la

# columna de la última reina colocada, el número de columnas del

# tablero y la solución parcial de las reinas colocadas anteriormente.

NodoNR = tuple[Columna, Columna, SolNR]

# valida(sp, p) se verifica si la posición p es válida respecto de la

# solución parcial sp; es decir, la reina en la posición p no amenaza a

# ninguna de las reinas de la sp (se supone que están en distintas

# columnas). Por ejemplo,

# valida([(1,1)], (2,2)) == False

# valida([(1,1)], (2,3)) == True

def valida(sp: SolNR, p: tuple[Columna, Fila]) -> bool:

c, r = p

def test(s: tuple[Columna, Fila]) -> bool:

c1, r1 = s

return c1 + r1 != c + r and c1 - r1 != c - r and r1 != r

return all(test(s) for s in sp)

# sucesoresNR(e) es la lista de los sucesores del estado e en el

# problema de las n reinas. Por ejemplo,

# >>> sucesoresNR((1,4,[]))

# [(2,4,[(1,1)]),(2,4,[(1,2)]),(2,4,[(1,3)]),(2,4,[(1,4)])]

def sucesoresNR (nd: NodoNR) -> list[NodoNR]:

c,n,solp = nd

return [(c+1,n,solp + [(c,r)]) for r in range(1, n+1) if valida(solp, (c,r))]

# esFinalNR(e) se verifica si e es un estado final del problema de las

# n reinas.

def esFinalNR(nd: NodoNR) -> bool:

c, n, _ = nd

return c > n

def solucionesNR(n: int) -> list[SolNR]:

nInicial: NodoNR = (1,n,[])

return [e for (_, _, e) in buscaProfundidad(sucesoresNR,

esFinalNR,

nInicial)]

def primeraSolucionNR(n: int) -> SolNR:

return solucionesNR(n)[0]

def nSolucionesNR(n: int) -> int:

return len(solucionesNR(n))

# Verificación

# ============

def test_nReinas() -> None:

assert solucionesNR(8)[:3] == \

[[(1,8),(2,4),(3,1),(4,3),(5,6),(6,2),(7,7),(8,5)],

[(1,8),(2,3),(3,1),(4,6),(5,2),(6,5),(7,7),(8,4)],

[(1,8),(2,2),(3,5),(4,3),(5,1),(6,7),(7,4),(8,6)]]

assert nSolucionesNR(8) == 92

print("Verificado")

# La verificación es

# >>> test_nReinas()

# Verificado

Búsqueda en espacios de estados por profundidad

PorJosé A. Alonso 28-junio-202327-junio-2023

Las características de los problemas de espacios de estados son:

un conjunto de las posibles situaciones o nodos que constituye el espacio de estados (estos son las potenciales soluciones que se necesitan explorar),
un conjunto de movimientos de un nodo a otros nodos, llamados los sucesores del nodo,
un nodo inicial y
un nodo objetivo que es la solución.

Definir la función

   buscaProfundidad :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)
                                  -> nodo -> [nodo]

1 2	buscaProfundidad :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool) -> nodo -> [nodo]

tal que buscaProfundidad s o e es la lista de soluciones del problema de espacio de estado definido por la función sucesores s, el objetivo o y estado inicial e obtenidas mediante búsqueda en profundidad.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module BusquedaEnProfundidad (buscaProfundidad) where

import TAD.Pila (apila, cima, desapila, esVacia, vacia)

buscaProfundidad :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)
                               -> nodo -> [nodo]
buscaProfundidad sucesores esFinal inicial =
  aux (apila inicial vacia)
  where
    aux p
      | esVacia p        = []
      | esFinal (cima p) = cima p : aux (desapila p)
      | otherwise        = aux (foldr
                                apila
                                (desapila p)
                                (sucesores (cima p)))

module BusquedaEnProfundidad (buscaProfundidad) where

import TAD.Pila (apila, cima, desapila, esVacia, vacia)

buscaProfundidad :: Eq nodo => (nodo -> [nodo]) -> (nodo -> Bool)

-> nodo -> [nodo]

buscaProfundidad sucesores esFinal inicial =

aux (apila inicial vacia)

where

aux p

| esVacia p = []

| esFinal (cima p) = cima p : aux (desapila p)

| otherwise = aux (foldr

apila

(desapila p)

(sucesores (cima p)))

Soluciones en Python

from functools import reduce
from sys import setrecursionlimit
from typing import Callable, TypeVar

from src.TAD.pila import Pila, apila, cima, desapila, esVacia, vacia

A = TypeVar('A')

setrecursionlimit(10**6)

def buscaProfundidad1(sucesores: Callable[[A], list[A]],
                      esFinal: Callable[[A], bool],
                      inicial: A) -> list[A]:
    def aux(p: Pila[A]) -> list[A]:
        if esVacia(p):
            return []
        if esFinal(cima(p)):
            return [cima(p)] + aux(desapila(p))
        return aux(reduce(lambda x, y: apila(y, x),
                          sucesores(cima(p)),
                          desapila(p)))

    return aux(apila(inicial, vacia()))

from functools import reduce

from sys import setrecursionlimit

from typing import Callable, TypeVar

from src.TAD.pila import Pila, apila, cima, desapila, esVacia, vacia

A = TypeVar('A')

setrecursionlimit(10**6)

def buscaProfundidad1(sucesores: Callable[[A], list[A]],

esFinal: Callable[[A], bool],

inicial: A) -> list[A]:

def aux(p: Pila[A]) -> list[A]:

if esVacia(p):

return []

if esFinal(cima(p)):

return [cima(p)] + aux(desapila(p))

return aux(reduce(lambda x, y: apila(y, x),

sucesores(cima(p)),

desapila(p)))

return aux(apila(inicial, vacia()))

Rompecabeza del triominó mediante divide y vencerás

PorJosé A. Alonso 27-junio-202321-junio-2023

Un poliominó es una figura geométrica plana formada conectando dos o más cuadrados por alguno de sus lados. Los cuadrados se conectan lado con lado, pero no se pueden conectar ni por sus vértices, ni juntando solo parte de un lado de un cuadrado con parte de un lado de otro. Si unimos dos cuadrados se obtiene un dominó, si se juntan tres cuadrados se construye un triominó.

Sólo existen dos triominós, el I-triomino (por tener forma de I) y el L-triominó (por su forma de L) como se observa en las siguientes figuras

   X
   X     X
   X     XX

X X

X XX

El rompecabeza del triominó consiste en cubrir un tablero cuadrado con 2^n filas y 2^n columnas, en el que se ha eliminado una casilla, con L-triominós de formas que cubran todas las casillas excepto la eliminada y los triominós no se solapen.

La casilla eliminada se representará con -1 y los L-triominós sucesiones de tres números consecutivos en forma de L. Con esta representación una solución del rompecabeza del triominó con 4 filas y la fila eliminada en la posición (4,4) es

   (  3  3  2  2 )
   (  3  1  1  2 )
   (  4  1  5  5 )
   (  4  4  5 -1 )

( 3 3 2 2 )

( 3 1 1 2 )

( 4 1 5 5 )

( 4 4 5 -1 )

Definir la función

   triomino :: Int -> Posicion -> Tablero

1	triomino :: Int -> Posicion -> Tablero

tal que (triomino n p) es la solución, mediante divide y vencerás, del rompecabeza del triominó en un cuadrado nxn en el que se ha eliminado la casilla de la posición p. Por ejemplo,

   λ> triomino 4 (4,4)
   (  3  3  2  2 )
   (  3  1  1  2 )
   (  4  1  5  5 )
   (  4  4  5 -1 )

   λ> triomino 4 (2,3)
   (  3  3  2  2 )
   (  3  1 -1  2 )
   (  4  1  1  5 )
   (  4  4  5  5 )

   λ> triomino 16 (5,6)
   (  7  7  6  6  6  6  5  5  6  6  5  5  5  5  4  4 )
   (  7  5  5  6  6  4  4  5  6  4  4  5  5  3  3  4 )
   (  8  5  9  9  7  7  4  8  7  4  8  8  6  6  3  7 )
   (  8  8  9  3  3  7  8  8  7  7  8  2  2  6  7  7 )
   (  8  8  7  3  9 -1  8  8  7  7  6  6  2  8  7  7 )
   (  8  6  7  7  9  9  7  8  7  5  5  6  8  8  6  7 )
   (  9  6  6 10 10  7  7 11  8  8  5  9  9  6  6 10 )
   (  9  9 10 10 10 10 11 11  1  8  9  9  9  9 10 10 )
   (  8  8  7  7  7  7  6  1  1  9  8  8  8  8  7  7 )
   (  8  6  6  7  7  5  6  6  9  9  7  8  8  6  6  7 )
   (  9  6 10 10  8  5  5  9 10  7  7 11  9  9  6 10 )
   (  9  9 10  4  8  8  9  9 10 10 11 11  5  9 10 10 )
   (  9  9  8  4  4 10  9  9 10 10  9  5  5 11 10 10 )
   (  9  7  8  8 10 10  8  9 10  8  9  9 11 11  9 10 )
   ( 10  7  7 11 11  8  8 12 11  8  8 12 12  9  9 13 )
   ( 10 10 11 11 11 11 12 12 11 11 12 12 12 12 13 13 )

λ> triomino 4 (4,4)

( 3 3 2 2 )

( 3 1 1 2 )

( 4 1 5 5 )

( 4 4 5 -1 )

λ> triomino 4 (2,3)

( 3 3 2 2 )

( 3 1 -1 2 )

( 4 1 1 5 )

( 4 4 5 5 )

λ> triomino 16 (5,6)

( 7 7 6 6 6 6 5 5 6 6 5 5 5 5 4 4 )

( 7 5 5 6 6 4 4 5 6 4 4 5 5 3 3 4 )

( 8 5 9 9 7 7 4 8 7 4 8 8 6 6 3 7 )

( 8 8 9 3 3 7 8 8 7 7 8 2 2 6 7 7 )

( 8 8 7 3 9 -1 8 8 7 7 6 6 2 8 7 7 )

( 8 6 7 7 9 9 7 8 7 5 5 6 8 8 6 7 )

( 9 6 6 10 10 7 7 11 8 8 5 9 9 6 6 10 )

( 9 9 10 10 10 10 11 11 1 8 9 9 9 9 10 10 )

( 8 8 7 7 7 7 6 1 1 9 8 8 8 8 7 7 )

( 8 6 6 7 7 5 6 6 9 9 7 8 8 6 6 7 )

( 9 6 10 10 8 5 5 9 10 7 7 11 9 9 6 10 )

( 9 9 10 4 8 8 9 9 10 10 11 11 5 9 10 10 )

( 9 9 8 4 4 10 9 9 10 10 9 5 5 11 10 10 )

( 9 7 8 8 10 10 8 9 10 8 9 9 11 11 9 10 )

( 10 7 7 11 11 8 8 12 11 8 8 12 12 9 9 13 )

( 10 10 11 11 11 11 12 12 11 11 12 12 12 12 13 13 )

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Rompecabeza_del_triomino_mediante_divide_y_venceras where

import DivideVenceras (divideVenceras)
import Data.Matrix
import Data.List (delete)
import Test.Hspec (Spec, hspec, it, shouldBe)

-- Los tableros son matrices de números enteros donde -1 representa el
-- hueco, 0 las posiciones sin rellenar y los números mayores que 0
-- representan los triominós.
type Tablero = Matrix Int

-- Los problemas se representarán mediante pares formados por un número
-- natural mayor que 0 (que indica el número con el que se formará el
-- siguiente triominó que se coloque) y un tablero.
type Problema = (Int,Tablero)

-- Las posiciones son pares de números enteros
type Posicion = (Int,Int)

triomino :: Int -> Posicion -> Tablero
triomino n p =
  divideVenceras ind resuelve divide combina (pbInicial n p)

-- (tablero n p) es el tablero inicial del problema del triominó
-- en un cuadrado nxn en el que se ha eliminado la casilla de la
-- posición (i,j). Por ejemplo,
--    λ> tablero 4 (3,4)
--    (  0  0  0  0 )
--    (  0  0  0  0 )
--    (  0  0  0 -1 )
--    (  0  0  0  0 )
tablero :: Int -> Posicion -> Tablero
tablero n (i,j) =
  setElem (-1) (i,j) (zero n n)

-- (pbInicial n p) es el problema inicial del rompecabeza del triominó
-- en un cuadrado nxn en el que se ha eliminado la casilla de la
-- posición p. Por ejemplo,
--    λ> pbInicial 4 (4,4)
--    (1,(  0  0  0  0 )
--       (  0  0  0  0 )
--       (  0  0  0  0 )
--       (  0  0  0 -1 ))
pbInicial :: Int -> Posicion -> Problema
pbInicial n p = (1,tablero n p)

-- (ind pb) se verifica si el problema pb es indivisible. Por ejemplo,
--    ind (pbInicial 2 (1,2))  ==  True
--    ind (pbInicial 4 (1,2))  ==  False
ind :: Problema -> Bool
ind (_,p) = ncols p == 2

-- (posicionHueco t) es la posición del hueco en el tablero t. Por
-- ejemplo,
--    posicionHueco (tablero 8 (5,2))  ==  (5,2)
posicionHueco :: Tablero -> Posicion
posicionHueco p =
  head [(i,j) | i <- [1..nrows p],
                j <- [1..ncols p],
                p!(i,j) /= 0]

-- (cuadranteHueco p) es el cuadrante donde se encuentra el hueco del
-- tablero t (donde la numeración de los cuadrantes es 1 el superior
-- izquierdo, 2 el inferior izquierdo, 3 el superior derecho y 4 el
-- inferior derecho). Por ejemplo,
--    cuadranteHueco (tablero 8 (4,4))  ==  1
--    cuadranteHueco (tablero 8 (5,2))  ==  2
--    cuadranteHueco (tablero 8 (3,6))  ==  3
--    cuadranteHueco (tablero 8 (6,6))  ==  4
cuadranteHueco :: Tablero -> Int
cuadranteHueco t
  | i <= x && j <= x = 1
  | i >  x && j <= x = 2
  | i <= x && j >  x = 3
  | otherwise        = 4
  where (i,j) = posicionHueco t
        x     = nrows t `div` 2

-- (centralHueco t) es la casilla central del cuadrante del tablero t
-- donde se encuentra el hueco. Por ejemplo,
--    centralHueco (tablero 8 (5,2))  ==  (5,4)
--    centralHueco (tablero 8 (4,4))  ==  (4,4)
--    centralHueco (tablero 8 (3,6))  ==  (4,5)
--    centralHueco (tablero 8 (6,6))  ==  (5,5)
centralHueco :: Tablero -> Posicion
centralHueco t =
  case cuadranteHueco t of
    1 -> (x,x)
    2 -> (x+1,x)
    3 -> (x,x+1)
    _ -> (x+1,x+1)
  where x = nrows t `div` 2

-- (centralesSinHueco t) son las posiciones centrales del tablero t de
-- los cuadrantes sin hueco. Por ejemplo,
--    centralesSinHueco (tablero 8 (5,2))  ==  [(4,4),(4,5),(5,5)]
centralesSinHueco :: Tablero -> [Posicion]
centralesSinHueco t =
  delete (i,j) [(x,x),(x+1,x),(x,x+1),(x+1,x+1)]
  where x     = nrows t `div` 2
        (i,j) = centralHueco t

-- (actualiza t ps) es la matriz obtenida cambiando en t los valores del
-- las posiciones indicadas en ps por sus correspondientes valores. Por
-- ejemplo,
--    λ> actualiza (identity 3) [((1,2),4),((3,1),5)]
--    ( 1 4 0 )
--    ( 0 1 0 )
--    ( 5 0 1 )
actualiza :: Matrix a -> [((Int,Int),a)] -> Matrix a
actualiza p []             = p
actualiza p (((i,j),x):zs) = setElem x (i,j) (actualiza p zs)

-- (triominoCentral (n,t) es el tablero obtenido colocando el triominó
-- formado por el número n en las posiciones centrales de los 3
-- cuadrantes que no contienen el hueco. Por ejemplo,
--    λ> triominoCentral (7,tablero 4 (4,4))
--    (  0  0  0  0 )
--    (  0  7  7  0 )
--    (  0  7  0  0 )
--    (  0  0  0 -1 )
triominoCentral :: Problema -> Tablero
triominoCentral (n,t) =
  actualiza t [((i,j),n) | (i,j) <- centralesSinHueco t]

-- (resuelve p) es la solución del problema indivisible p. Por ejemplo,
--    λ> tablero 2 (2,2)
--    (  0  0 )
--    (  0 -1 )
--
--    λ> resuelve (5,tablero 2 (2,2))
--    (  5  5 )
--    (  5 -1 )
resuelve :: Problema -> Tablero
resuelve = triominoCentral

-- (divide (n,t)) es la lista de de los problemas obtenidos colocando el
-- triominó n en las casillas centrales de t que no contienen el hueco y
-- dividir el tablero en sus cuatros cuadrantes y aumentar en uno el
-- número del correspondiente triominó. Por ejemplo,
--    λ> divide (3,tablero 4 (4,4))
--    [(4,(  0  0 )
--        (  3  0 )),
--     (5,(  0  0 )
--        (  0  3 )),
--     (6,(  0  3 )
--        (  0  0 )),
--     (7,(  0  0 )
--        (  0 -1 ))]
divide :: Problema -> [Problema]
divide (n,t) =
  [(n+1, submatrix 1     x (x+1) m q),
   (n+2, submatrix 1     x 1     x q),
   (n+3, submatrix (x+1) m 1     x q),
   (n+4, submatrix (x+1) m (x+1) m q)]
  where q = triominoCentral (n,t)
        m = nrows t
        x = m `div` 2

-- (combina p ts) es la combinación de las soluciones ts de los
-- subproblemas del problema p. Por ejemplo,
--    λ> let inicial = (1,tablero 4 (4,4)) :: (Int,Matrix Int)
--    λ> let [p1,p2,p3,p4] = divide inicial
--    λ> let [s1,s2,s3,s4] = map resuelve [p1,p2,p3,p4]
--    λ> combina inicial [s1,s2,s3,s4]
--    (  3  3  2  2 )
--    (  3  1  1  2 )
--    (  4  1  5  5 )
--    (  4  4  5 -1 )
combina :: Problema -> [Tablero] -> Tablero
combina _ [s1,s2,s3,s4] = joinBlocks (s2,s1,s3,s4)
combina _ _             = error "Imposible"

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    toLists (triomino 4 (4,4)) `shouldBe`
    [[3,3,2,2],
     [3,1,1,2],
     [4,1,5,5],
     [4,4,5,-1]]
  it "e2" $
    toLists (triomino 4 (2,3)) `shouldBe`
    [[3,3,2,2],
     [3,1,-1,2],
     [4,1,1,5],
     [4,4,5,5]]
  it "e3" $
    toLists (triomino 16 (5,6)) `shouldBe`
    [[7,7,6,6,6,6,5,5,6,6,5,5,5,5,4,4],
     [7,5,5,6,6,4,4,5,6,4,4,5,5,3,3,4],
     [8,5,9,9,7,7,4,8,7,4,8,8,6,6,3,7],
     [8,8,9,3,3,7,8,8,7,7,8,2,2,6,7,7],
     [8,8,7,3,9,-1,8,8,7,7,6,6,2,8,7,7],
     [8,6,7,7,9,9,7,8,7,5,5,6,8,8,6,7],
     [9,6,6,10,10,7,7,11,8,8,5,9,9,6,6,10],
     [9,9,10,10,10,10,11,11,1,8,9,9,9,9,10,10],
     [8,8,7,7,7,7,6,1,1,9,8,8,8,8,7,7],
     [8,6,6,7,7,5,6,6,9,9,7,8,8,6,6,7],
     [9,6,10,10,8,5,5,9,10,7,7,11,9,9,6,10],
     [9,9,10,4,8,8,9,9,10,10,11,11,5,9,10,10],
     [9,9,8,4,4,10,9,9,10,10,9,5,5,11,10,10],
     [9,7,8,8,10,10,8,9,10,8,9,9,11,11,9,10],
     [10,7,7,11,11,8,8,12,11,8,8,12,12,9,9,13],
     [10,10,11,11,11,11,12,12,11,11,12,12,12,12,13,13]]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--
--    Finished in 0.0018 seconds
--    3 examples, 0 failures

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

module Rompecabeza_del_triomino_mediante_divide_y_venceras where

import DivideVenceras (divideVenceras)

import Data.Matrix

import Data.List (delete)

import Test.Hspec (Spec, hspec, it, shouldBe)

-- Los tableros son matrices de números enteros donde -1 representa el

-- hueco, 0 las posiciones sin rellenar y los números mayores que 0

-- representan los triominós.

type Tablero = Matrix Int

-- Los problemas se representarán mediante pares formados por un número

-- natural mayor que 0 (que indica el número con el que se formará el

-- siguiente triominó que se coloque) y un tablero.

type Problema = (Int,Tablero)

-- Las posiciones son pares de números enteros

type Posicion = (Int,Int)

triomino :: Int -> Posicion -> Tablero

triomino n p =

divideVenceras ind resuelve divide combina (pbInicial n p)

-- (tablero n p) es el tablero inicial del problema del triominó

-- en un cuadrado nxn en el que se ha eliminado la casilla de la

-- posición (i,j). Por ejemplo,

-- λ> tablero 4 (3,4)

-- ( 0 0 0 0 )

-- ( 0 0 0 -1 )

-- ( 0 0 0 0 )

tablero :: Int -> Posicion -> Tablero

tablero n (i,j) =

setElem (-1) (i,j) (zero n n)

-- (pbInicial n p) es el problema inicial del rompecabeza del triominó

-- en un cuadrado nxn en el que se ha eliminado la casilla de la

-- posición p. Por ejemplo,

-- λ> pbInicial 4 (4,4)

-- (1,( 0 0 0 0 )

-- ( 0 0 0 0 )

-- ( 0 0 0 -1 ))

pbInicial :: Int -> Posicion -> Problema

pbInicial n p = (1,tablero n p)

-- (ind pb) se verifica si el problema pb es indivisible. Por ejemplo,

-- ind (pbInicial 2 (1,2)) == True

-- ind (pbInicial 4 (1,2)) == False

ind :: Problema -> Bool

ind (_,p) = ncols p == 2

-- (posicionHueco t) es la posición del hueco en el tablero t. Por

-- ejemplo,

-- posicionHueco (tablero 8 (5,2)) == (5,2)

posicionHueco :: Tablero -> Posicion

posicionHueco p =

head [(i,j) | i <- [1..nrows p],

j <- [1..ncols p],

p!(i,j) /= 0]

-- (cuadranteHueco p) es el cuadrante donde se encuentra el hueco del

-- tablero t (donde la numeración de los cuadrantes es 1 el superior

-- izquierdo, 2 el inferior izquierdo, 3 el superior derecho y 4 el

-- inferior derecho). Por ejemplo,

-- cuadranteHueco (tablero 8 (4,4)) == 1

-- cuadranteHueco (tablero 8 (5,2)) == 2

-- cuadranteHueco (tablero 8 (3,6)) == 3

-- cuadranteHueco (tablero 8 (6,6)) == 4

cuadranteHueco :: Tablero -> Int

cuadranteHueco t

| i <= x && j <= x = 1

| i > x && j <= x = 2

| i <= x && j > x = 3

| otherwise = 4

where (i,j) = posicionHueco t

x = nrows t `div` 2

-- (centralHueco t) es la casilla central del cuadrante del tablero t

-- donde se encuentra el hueco. Por ejemplo,

-- centralHueco (tablero 8 (5,2)) == (5,4)

-- centralHueco (tablero 8 (4,4)) == (4,4)

-- centralHueco (tablero 8 (3,6)) == (4,5)

-- centralHueco (tablero 8 (6,6)) == (5,5)

centralHueco :: Tablero -> Posicion

centralHueco t =

case cuadranteHueco t of

1 -> (x,x)

2 -> (x+1,x)

3 -> (x,x+1)

_ -> (x+1,x+1)

where x = nrows t `div` 2

-- (centralesSinHueco t) son las posiciones centrales del tablero t de

-- los cuadrantes sin hueco. Por ejemplo,

-- centralesSinHueco (tablero 8 (5,2)) == [(4,4),(4,5),(5,5)]

centralesSinHueco :: Tablero -> [Posicion]

centralesSinHueco t =

delete (i,j) [(x,x),(x+1,x),(x,x+1),(x+1,x+1)]

where x = nrows t `div` 2

(i,j) = centralHueco t

-- (actualiza t ps) es la matriz obtenida cambiando en t los valores del

-- las posiciones indicadas en ps por sus correspondientes valores. Por

-- ejemplo,

-- λ> actualiza (identity 3) [((1,2),4),((3,1),5)]

-- ( 1 4 0 )

-- ( 0 1 0 )

-- ( 5 0 1 )

actualiza :: Matrix a -> [((Int,Int),a)] -> Matrix a

actualiza p [] = p

actualiza p (((i,j),x):zs) = setElem x (i,j) (actualiza p zs)

-- (triominoCentral (n,t) es el tablero obtenido colocando el triominó

-- formado por el número n en las posiciones centrales de los 3

-- cuadrantes que no contienen el hueco. Por ejemplo,

-- λ> triominoCentral (7,tablero 4 (4,4))

-- ( 0 0 0 0 )

-- ( 0 7 7 0 )

-- ( 0 7 0 0 )

-- ( 0 0 0 -1 )

triominoCentral :: Problema -> Tablero

triominoCentral (n,t) =

actualiza t [((i,j),n) | (i,j) <- centralesSinHueco t]

-- (resuelve p) es la solución del problema indivisible p. Por ejemplo,

-- λ> tablero 2 (2,2)

-- ( 0 0 )

-- ( 0 -1 )

-- λ> resuelve (5,tablero 2 (2,2))

-- ( 5 5 )

-- ( 5 -1 )

resuelve :: Problema -> Tablero

resuelve = triominoCentral

-- (divide (n,t)) es la lista de de los problemas obtenidos colocando el

-- triominó n en las casillas centrales de t que no contienen el hueco y

-- dividir el tablero en sus cuatros cuadrantes y aumentar en uno el

-- número del correspondiente triominó. Por ejemplo,

-- λ> divide (3,tablero 4 (4,4))

-- [(4,( 0 0 )

-- ( 3 0 )),

-- (5,( 0 0 )

-- ( 0 3 )),

-- (6,( 0 3 )

-- ( 0 0 )),

-- (7,( 0 0 )

-- ( 0 -1 ))]

divide :: Problema -> [Problema]

divide (n,t) =

[(n+1, submatrix 1 x (x+1) m q),

(n+2, submatrix 1 x 1 x q),

(n+3, submatrix (x+1) m 1 x q),

(n+4, submatrix (x+1) m (x+1) m q)]

where q = triominoCentral (n,t)

m = nrows t

x = m `div` 2

-- (combina p ts) es la combinación de las soluciones ts de los

-- subproblemas del problema p. Por ejemplo,

-- λ> let inicial = (1,tablero 4 (4,4)) :: (Int,Matrix Int)

-- λ> let [p1,p2,p3,p4] = divide inicial

-- λ> let [s1,s2,s3,s4] = map resuelve [p1,p2,p3,p4]

-- λ> combina inicial [s1,s2,s3,s4]

-- ( 3 3 2 2 )

-- ( 3 1 1 2 )

-- ( 4 1 5 5 )

-- ( 4 4 5 -1 )

combina :: Problema -> [Tablero] -> Tablero

combina _ [s1,s2,s3,s4] = joinBlocks (s2,s1,s3,s4)

combina _ _ = error "Imposible"

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

toLists (triomino 4 (4,4)) `shouldBe`

[[3,3,2,2],

[3,1,1,2],

[4,1,5,5],

[4,4,5,-1]]

it "e2" $

toLists (triomino 4 (2,3)) `shouldBe`

[[3,3,2,2],

[3,1,-1,2],

[4,1,1,5],

[4,4,5,5]]

it "e3" $

toLists (triomino 16 (5,6)) `shouldBe`

[[7,7,6,6,6,6,5,5,6,6,5,5,5,5,4,4],

[7,5,5,6,6,4,4,5,6,4,4,5,5,3,3,4],

[8,5,9,9,7,7,4,8,7,4,8,8,6,6,3,7],

[8,8,9,3,3,7,8,8,7,7,8,2,2,6,7,7],

[8,8,7,3,9,-1,8,8,7,7,6,6,2,8,7,7],

[8,6,7,7,9,9,7,8,7,5,5,6,8,8,6,7],

[9,6,6,10,10,7,7,11,8,8,5,9,9,6,6,10],

[9,9,10,10,10,10,11,11,1,8,9,9,9,9,10,10],

[8,8,7,7,7,7,6,1,1,9,8,8,8,8,7,7],

[8,6,6,7,7,5,6,6,9,9,7,8,8,6,6,7],

[9,6,10,10,8,5,5,9,10,7,7,11,9,9,6,10],

[9,9,10,4,8,8,9,9,10,10,11,11,5,9,10,10],

[9,9,8,4,4,10,9,9,10,10,9,5,5,11,10,10],

[9,7,8,8,10,10,8,9,10,8,9,9,11,11,9,10],

[10,7,7,11,11,8,8,12,11,8,8,12,12,9,9,13],

[10,10,11,11,11,11,12,12,11,11,12,12,12,12,13,13]]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- Finished in 0.0018 seconds

-- 3 examples, 0 failures

Soluciones en Python

import numpy as np
import numpy.typing as npt

from src.DivideVenceras import divideVenceras

# Los tableros son matrices de números enteros donde -1 representa el
# hueco, 0 las posiciones sin rellenar y los números mayores que 0
# representan los triominós.
Tablero = npt.NDArray[np.complex64]

# Los problemas se representarán mediante pares formados por un número
# natural mayor que 0 (que indica el número con el que se formará el
# siguiente triominó que se coloque) y un tablero.
Problema = tuple[int, Tablero]

# Las posiciones son pares de números enteros
Posicion = tuple[int, int]

# tablero(n p) es el tablero inicial del problema del triominó
# en un cuadrado nxn en el que se ha eliminado la casilla de la
# posición p. Por ejemplo,
#    >>> tablero(4, (3,4))
#    array([[ 0,  0,  0,  0],
#           [ 0,  0,  0,  0],
#           [ 0,  0,  0, -1],
#           [ 0,  0,  0,  0]])
def tablero(n: int, p: Posicion) -> Tablero:
    (i, j) = p
    q = np.zeros((n, n), dtype=int)
    q[i - 1, j - 1] = -1
    return q

# pbInicial(n, p) es el problema inicial del rompecabeza del triominó
# en un cuadrado nxn en el que se ha eliminado la casilla de la
# posición p. Por ejemplo,
#    >>> pbInicial(4, (4,4))
#    (1, array([[ 0,  0,  0,  0],
#           [ 0,  0,  0,  0],
#           [ 0,  0,  0,  0],
#           [ 0,  0,  0, -1]]))
def pbInicial(n: int, p: Posicion) -> Problema:
    return 1, tablero(n, p)

# ind(pb) se verifica si el problema pb es indivisible. Por ejemplo,
#    ind(pbInicial(2, (1,2)))  ==  True
#    ind(pbInicial(4, (1,2)))  ==  False
def ind(pb: Problema) -> bool:
    _, p = pb
    return p.shape[1] == 2

# posicionHueco(t) es la posición del hueco en el tablero t. Por
# ejemplo,
#    posicionHueco(tablero(8, (5,2)))  ==  (5,2)
def posicionHueco(t: Tablero) -> Posicion:
    indices = np.argwhere(t != 0)
    (i, j) =  tuple(indices[0])
    return (i + 1, j + 1)

# cuadranteHueco(p) es el cuadrante donde se encuentra el hueco del
# tablero t (donde la numeración de los cuadrantes es 1 el superior
# izquierdo, 2 el inferior izquierdo, 3 el superior derecho y 4 el
# inferior derecho). Por ejemplo,
#    cuadranteHueco(tablero(8, (4,4)))  ==  1
#    cuadranteHueco(tablero(8, (5,2)))  ==  2
#    cuadranteHueco(tablero(8, (3,6)))  ==  3
#    cuadranteHueco(tablero(8, (6,6)))  ==  4
def cuadranteHueco(t: Tablero) -> int:
    i, j = posicionHueco(t)
    x = t.shape[0] // 2
    if j <= x:
        if i <= x:
            return 1
        return 2
    if i <= x:
        return 3
    return 4

# centralHueco(t) es la casilla central del cuadrante del tablero t
# donde se encuentra el hueco. Por ejemplo,
#    centralHueco(tablero(8, (5,2)))  ==  (5,4)
#    centralHueco(tablero(8, (4,4)))  ==  (4,4)
#    centralHueco(tablero(8, (3,6)))  ==  (4,5)
#    centralHueco(tablero(8, (6,6)))  ==  (5,5)
def centralHueco(t: Tablero) -> Posicion:
    x = t.shape[0] // 2
    cuadrante = cuadranteHueco(t)
    if cuadrante == 1:
        return (x, x)
    if cuadrante == 2:
        return (x+1, x)
    if cuadrante == 3:
        return (x, x+1)
    return (x+1, x+1)

# centralesSinHueco(t) son las posiciones centrales del tablero t de
# los cuadrantes sin hueco. Por ejemplo,
#    centralesSinHueco(tablero(8, (5,2)))  ==  [(4,4),(4,5),(5,5)]
def centralesSinHueco(t: Tablero) -> list[Posicion]:
    x = t.shape[0] // 2
    i, j = centralHueco(t)
    ps = [(x, x), (x+1, x), (x, x+1), (x+1, x+1)]
    return [p for p in ps if p != (i, j)]

# actualiza(t, ps) es la matriz obtenida cambiando en t los valores del
# las posiciones indicadas en ps por sus correspondientes valores. Por
# ejemplo,
#    >>> actualiza(np.identity(3, dtype=int), [((1,2),4),((3,1),5)])
#    array([[1, 4, 0],
#           [0, 1, 0],
#           [5, 0, 1]])
def actualiza(p: Tablero, ps: list[tuple[Posicion, int]]) -> Tablero:
    for (i, j), x in ps:
        p[i - 1, j - 1] = x
    return p

# triominoCentral(n,t) es el tablero obtenido colocando el triominó
# formado por el número n en las posiciones centrales de los 3
# cuadrantes que no contienen el hueco. Por ejemplo,
#    >>> triominoCentral((7, tablero(4, (4,4))))
#    array([[ 0,  0,  0,  0],
#           [ 0,  7,  7,  0],
#           [ 0,  7,  0,  0],
#           [ 0,  0,  0, -1]])
def triominoCentral(p: Problema) -> Tablero:
    n, t = p
    return actualiza(t, [((i,j),n) for (i,j) in centralesSinHueco(t)])

# resuelve(p) es la solución del problema indivisible p. Por ejemplo,
#    >>> tablero(2, (2,2))
#    array([[ 0,  0],
#           [ 0, -1]])
#    >>> resuelve((5,tablero(2, (2,2))))
#    array([[ 5,  5],
#           [ 5, -1]])
def resuelve(p: Problema) -> Tablero:
    return triominoCentral(p)

# divide(n,t) es la lista de de los problemas obtenidos colocando el
# triominó n en las casillas centrales de t que no contienen el hueco y
# dividir el tablero en sus cuatros cuadrantes y aumentar en uno el
# número del correspondiente triominó. Por ejemplo,
#    >>> divide((3,tablero(4, (4,4))))
#    [(4, array([[0, 0],
#                [3, 0]])),
#     (5, array([[0, 0],
#                [0, 3]])),
#     (6, array([[0, 3],
#                [0, 0]])),
#     (7, array([[ 0,  0],
#                [ 0, -1]]))]
def divide(p: Problema) -> list[Problema]:
    q = triominoCentral(p)
    n, t = p
    m = t.shape[0]
    x = m // 2
    subproblemas = [
        (n+1, q[0:x, x:m]),
        (n+2, q[0:x, 0:x]),
        (n+3, q[x:m, 0:x]),
        (n+4, q[x:m, x:m])
    ]
    return subproblemas

# combina(p, ts) es la combinación de las soluciones ts de los
# subproblemas del problema p. Por ejemplo,
#    >>> inicial = (1, tablero(4, (4, 4)))
#    >>> p1, p2, p3, p4 = divide(inicial)
#    >>> s1, s2, s3, s4 = map(resuelve, [p1, p2, p3, p4])
#    >>> combina(inicial, [s1, s2, s3, s4])
#    array([[ 3,  3,  2,  2],
#           [ 3,  1,  1,  2],
#           [ 4,  1,  5,  5],
#           [ 4,  4,  5, -1]])
def combina(_: Problema, ts: list[Tablero]) -> Tablero:
    s1, s2, s3, s4 = ts
    combined = np.block([[s2, s1], [s3, s4]])
    return combined

def triomino(n: int, p: Posicion) -> Tablero:
    return divideVenceras(ind, resuelve, divide, combina, pbInicial(n, p))

# Verificación
# ============

def test_triomino() -> None:
    def filas(p: Tablero) -> list[list[int]]:
        return p.tolist()

    assert filas(triomino(4, (4,4))) == \
        [[3,3,2,2],[3,1,1,2],[4,1,5,5],[4,4,5,-1]]
    assert filas(triomino(4, (2,3))) == \
        [[3,3,2,2],[3,1,-1,2],[4,1,1,5],[4,4,5,5]]
    assert filas(triomino(16, (5,6))) == \
        [[7,7,6,6,6,6,5,5,6,6,5,5,5,5,4,4],
         [7,5,5,6,6,4,4,5,6,4,4,5,5,3,3,4],
         [8,5,9,9,7,7,4,8,7,4,8,8,6,6,3,7],
         [8,8,9,3,3,7,8,8,7,7,8,2,2,6,7,7],
         [8,8,7,3,9,-1,8,8,7,7,6,6,2,8,7,7],
         [8,6,7,7,9,9,7,8,7,5,5,6,8,8,6,7],
         [9,6,6,10,10,7,7,11,8,8,5,9,9,6,6,10],
         [9,9,10,10,10,10,11,11,1,8,9,9,9,9,10,10],
         [8,8,7,7,7,7,6,1,1,9,8,8,8,8,7,7],
         [8,6,6,7,7,5,6,6,9,9,7,8,8,6,6,7],
         [9,6,10,10,8,5,5,9,10,7,7,11,9,9,6,10],
         [9,9,10,4,8,8,9,9,10,10,11,11,5,9,10,10],
         [9,9,8,4,4,10,9,9,10,10,9,5,5,11,10,10],
         [9,7,8,8,10,10,8,9,10,8,9,9,11,11,9,10],
         [10,7,7,11,11,8,8,12,11,8,8,12,12,9,9,13],
         [10,10,11,11,11,11,12,12,11,11,12,12,12,12,13,13]]
    print("Verificado")

# La verificación es
#    >>> test_triomino()
#    Verificado

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

import numpy as np

import numpy.typing as npt

from src.DivideVenceras import divideVenceras

# Los tableros son matrices de números enteros donde -1 representa el

# hueco, 0 las posiciones sin rellenar y los números mayores que 0

# representan los triominós.

Tablero = npt.NDArray[np.complex64]

# Los problemas se representarán mediante pares formados por un número

# natural mayor que 0 (que indica el número con el que se formará el

# siguiente triominó que se coloque) y un tablero.

Problema = tuple[int, Tablero]

# Las posiciones son pares de números enteros

Posicion = tuple[int, int]

# tablero(n p) es el tablero inicial del problema del triominó

# en un cuadrado nxn en el que se ha eliminado la casilla de la

# posición p. Por ejemplo,

# >>> tablero(4, (3,4))

# array([[ 0, 0, 0, 0],

# [ 0, 0, 0, 0],

# [ 0, 0, 0, -1],

# [ 0, 0, 0, 0]])

def tablero(n: int, p: Posicion) -> Tablero:

(i, j) = p

q = np.zeros((n, n), dtype=int)

q[i - 1, j - 1] = -1

return q

# pbInicial(n, p) es el problema inicial del rompecabeza del triominó

# en un cuadrado nxn en el que se ha eliminado la casilla de la

# posición p. Por ejemplo,

# >>> pbInicial(4, (4,4))

# (1, array([[ 0, 0, 0, 0],

# [ 0, 0, 0, 0],

# [ 0, 0, 0, -1]]))

def pbInicial(n: int, p: Posicion) -> Problema:

return 1, tablero(n, p)

# ind(pb) se verifica si el problema pb es indivisible. Por ejemplo,

# ind(pbInicial(2, (1,2))) == True

# ind(pbInicial(4, (1,2))) == False

def ind(pb: Problema) -> bool:

_, p = pb

return p.shape[1] == 2

# posicionHueco(t) es la posición del hueco en el tablero t. Por

# ejemplo,

# posicionHueco(tablero(8, (5,2))) == (5,2)

def posicionHueco(t: Tablero) -> Posicion:

indices = np.argwhere(t != 0)

(i, j) = tuple(indices[0])

return (i + 1, j + 1)

# cuadranteHueco(p) es el cuadrante donde se encuentra el hueco del

# tablero t (donde la numeración de los cuadrantes es 1 el superior

# izquierdo, 2 el inferior izquierdo, 3 el superior derecho y 4 el

# inferior derecho). Por ejemplo,

# cuadranteHueco(tablero(8, (4,4))) == 1

# cuadranteHueco(tablero(8, (5,2))) == 2

# cuadranteHueco(tablero(8, (3,6))) == 3

# cuadranteHueco(tablero(8, (6,6))) == 4

def cuadranteHueco(t: Tablero) -> int:

i, j = posicionHueco(t)

x = t.shape[0] // 2

if j <= x:

if i <= x:

return 1

return 2

if i <= x:

return 3

return 4

# centralHueco(t) es la casilla central del cuadrante del tablero t

# donde se encuentra el hueco. Por ejemplo,

# centralHueco(tablero(8, (5,2))) == (5,4)

# centralHueco(tablero(8, (4,4))) == (4,4)

# centralHueco(tablero(8, (3,6))) == (4,5)

# centralHueco(tablero(8, (6,6))) == (5,5)

def centralHueco(t: Tablero) -> Posicion:

x = t.shape[0] // 2

cuadrante = cuadranteHueco(t)

if cuadrante == 1:

return (x, x)

if cuadrante == 2:

return (x+1, x)

if cuadrante == 3:

return (x, x+1)

return (x+1, x+1)

# centralesSinHueco(t) son las posiciones centrales del tablero t de

# los cuadrantes sin hueco. Por ejemplo,

# centralesSinHueco(tablero(8, (5,2))) == [(4,4),(4,5),(5,5)]

def centralesSinHueco(t: Tablero) -> list[Posicion]:

x = t.shape[0] // 2

i, j = centralHueco(t)

ps = [(x, x), (x+1, x), (x, x+1), (x+1, x+1)]

return [p for p in ps if p != (i, j)]

# actualiza(t, ps) es la matriz obtenida cambiando en t los valores del

# las posiciones indicadas en ps por sus correspondientes valores. Por

# ejemplo,

# >>> actualiza(np.identity(3, dtype=int), [((1,2),4),((3,1),5)])

# array([[1, 4, 0],

# [0, 1, 0],

# [5, 0, 1]])

def actualiza(p: Tablero, ps: list[tuple[Posicion, int]]) -> Tablero:

for (i, j), x in ps:

p[i - 1, j - 1] = x

return p

# triominoCentral(n,t) es el tablero obtenido colocando el triominó

# formado por el número n en las posiciones centrales de los 3

# cuadrantes que no contienen el hueco. Por ejemplo,

# >>> triominoCentral((7, tablero(4, (4,4))))

# array([[ 0, 0, 0, 0],

# [ 0, 7, 7, 0],

# [ 0, 7, 0, 0],

# [ 0, 0, 0, -1]])

def triominoCentral(p: Problema) -> Tablero:

n, t = p

return actualiza(t, [((i,j),n) for (i,j) in centralesSinHueco(t)])

# resuelve(p) es la solución del problema indivisible p. Por ejemplo,

# >>> tablero(2, (2,2))

# array([[ 0, 0],

# [ 0, -1]])

# >>> resuelve((5,tablero(2, (2,2))))

# array([[ 5, 5],

# [ 5, -1]])

def resuelve(p: Problema) -> Tablero:

return triominoCentral(p)

# divide(n,t) es la lista de de los problemas obtenidos colocando el

# triominó n en las casillas centrales de t que no contienen el hueco y

# dividir el tablero en sus cuatros cuadrantes y aumentar en uno el

# número del correspondiente triominó. Por ejemplo,

# >>> divide((3,tablero(4, (4,4))))

# [(4, array([[0, 0],

# [3, 0]])),

# (5, array([[0, 0],

# [0, 3]])),

# (6, array([[0, 3],

# [0, 0]])),

# (7, array([[ 0, 0],

# [ 0, -1]]))]

def divide(p: Problema) -> list[Problema]:

q = triominoCentral(p)

n, t = p

m = t.shape[0]

x = m // 2

subproblemas = [

(n+1, q[0:x, x:m]),

(n+2, q[0:x, 0:x]),

(n+3, q[x:m, 0:x]),

(n+4, q[x:m, x:m])

]

return subproblemas

# combina(p, ts) es la combinación de las soluciones ts de los

# subproblemas del problema p. Por ejemplo,

# >>> inicial = (1, tablero(4, (4, 4)))

# >>> p1, p2, p3, p4 = divide(inicial)

# >>> s1, s2, s3, s4 = map(resuelve, [p1, p2, p3, p4])

# >>> combina(inicial, [s1, s2, s3, s4])

# array([[ 3, 3, 2, 2],

# [ 3, 1, 1, 2],

# [ 4, 1, 5, 5],

# [ 4, 4, 5, -1]])

def combina(_: Problema, ts: list[Tablero]) -> Tablero:

s1, s2, s3, s4 = ts

combined = np.block([[s2, s1], [s3, s4]])

return combined

def triomino(n: int, p: Posicion) -> Tablero:

return divideVenceras(ind, resuelve, divide, combina, pbInicial(n, p))

# Verificación

# ============

def test_triomino() -> None:

def filas(p: Tablero) -> list[list[int]]:

return p.tolist()

assert filas(triomino(4, (4,4))) == \

[[3,3,2,2],[3,1,1,2],[4,1,5,5],[4,4,5,-1]]

assert filas(triomino(4, (2,3))) == \

[[3,3,2,2],[3,1,-1,2],[4,1,1,5],[4,4,5,5]]

assert filas(triomino(16, (5,6))) == \

[[7,7,6,6,6,6,5,5,6,6,5,5,5,5,4,4],

[7,5,5,6,6,4,4,5,6,4,4,5,5,3,3,4],

[8,5,9,9,7,7,4,8,7,4,8,8,6,6,3,7],

[8,8,9,3,3,7,8,8,7,7,8,2,2,6,7,7],

[8,8,7,3,9,-1,8,8,7,7,6,6,2,8,7,7],

[8,6,7,7,9,9,7,8,7,5,5,6,8,8,6,7],

[9,6,6,10,10,7,7,11,8,8,5,9,9,6,6,10],

[9,9,10,10,10,10,11,11,1,8,9,9,9,9,10,10],

[8,8,7,7,7,7,6,1,1,9,8,8,8,8,7,7],

[8,6,6,7,7,5,6,6,9,9,7,8,8,6,6,7],

[9,6,10,10,8,5,5,9,10,7,7,11,9,9,6,10],

[9,9,10,4,8,8,9,9,10,10,11,11,5,9,10,10],

[9,9,8,4,4,10,9,9,10,10,9,5,5,11,10,10],

[9,7,8,8,10,10,8,9,10,8,9,9,11,11,9,10],

[10,7,7,11,11,8,8,12,11,8,8,12,12,9,9,13],

[10,10,11,11,11,11,12,12,11,11,12,12,12,12,13,13]]

print("Verificado")

# La verificación es

# >>> test_triomino()

# Verificado

Algoritmo divide y vencerás

PorJosé A. Alonso 26-junio-202319-junio-2023

La técnica divide y vencerás consta de los siguientes pasos:

Dividir el problema en subproblemas menores.
Resolver por separado cada uno de los subproblemas:
- si los subproblemas son complejos, usar la misma técnica recursivamente;
- si son simples, resolverlos directamente.
Combinar todas las soluciones de los subproblemas en una solución simple.

Definir la función

   divideVenceras :: (p -> Bool)
                  -> (p -> s)
                  -> (p -> [p])
                  -> (p -> [s] -> s)
                  -> p
                  -> s

divideVenceras :: (p -> Bool)

-> (p -> s)

-> (p -> [p])

-> (p -> [s] -> s)

-> p

-> s

tal que divideVenceras ind resuelve divide combina pbInicial resuelve el problema pbInicial mediante la técnica de divide y vencerás, donde

ind pb se verifica si el problema pb es indivisible
resuelve pb es la solución del problema indivisible pb
divide pb es la lista de subproblemas de pb
combina pb ss es la combinación de las soluciones ss de los subproblemas del problema pb.
pbInicial es el problema inicial

Usando la función DivideVenceras, definir las funciones

   ordenaPorMezcla :: Ord a => [a] -> [a]
   ordenaRapida    :: Ord a => [a] -> [a]

1 2	ordenaPorMezcla :: Ord a => [a] -> [a] ordenaRapida :: Ord a => [a] -> [a]

tales que

ordenaPorMezcla xs es la lista obtenida ordenando xs por el procedimiento de ordenación por mezcla. Por ejemplo,

     λ> ordenaPorMezcla [3,1,4,1,5,9,2,8]
     [1,1,2,3,4,5,8,9]

1 2	λ> ordenaPorMezcla [3,1,4,1,5,9,2,8] [1,1,2,3,4,5,8,9]

ordenaRapida xs es la lista obtenida ordenando xs por el procedimiento de ordenación rápida. Por ejemplo,

     λ> ordenaRapida [3,1,4,1,5,9,2,8]
     [1,1,2,3,4,5,8,9]

1 2	λ> ordenaRapida [3,1,4,1,5,9,2,8] [1,1,2,3,4,5,8,9]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module DivideVenceras (divideVenceras) where

import Test.Hspec (Spec, hspec, it, shouldBe)

divideVenceras :: (p -> Bool)
               -> (p -> s)
               -> (p -> [p])
               -> (p -> [s] -> s)
               -> p
               -> s
divideVenceras ind resuelve divide combina = dv'
  where
    dv' pb
      | ind pb    = resuelve pb
      | otherwise = combina pb [dv' sp | sp <- divide pb]

ordenaPorMezcla :: Ord a => [a] -> [a]
ordenaPorMezcla =
    divideVenceras ind id divide combina
    where
      ind xs            = length xs <= 1
      divide xs         = [take n xs, drop n xs]
                          where n = length xs `div` 2
      combina _ [l1,l2] = mezcla l1 l2

-- (mezcla xs ys) es la lista obtenida mezclando xs e ys. Por ejemplo,
--    mezcla [1,3] [2,4,6]  ==  [1,2,3,4,6]
mezcla :: Ord a => [a] -> [a] -> [a]
mezcla [] b = b
mezcla a [] = a
mezcla a@(x:xs) b@(y:ys) | x <= y    = x : mezcla xs b
                         | otherwise = y : mezcla a ys

ordenaRapida :: Ord a => [a] -> [a]
ordenaRapida =
    divideVenceras ind id divide combina
    where
      ind xs                = length xs <= 1
      divide (x:xs)         = [[ y | y <- xs, y <= x],
                               [ y | y <- xs, y > x]]
      combina (x:_) [l1,l2] = l1 ++ [x] ++ l2

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    ordenaPorMezcla [3,1,4,1,5,9,2,8] `shouldBe` [1,1,2,3,4,5,8,9]
  it "e2" $
    ordenaRapida [3,1,4,1,5,9,2,8] `shouldBe` [1,1,2,3,4,5,8,9]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.0004 seconds
--    2 examples, 0 failures

module DivideVenceras (divideVenceras) where

import Test.Hspec (Spec, hspec, it, shouldBe)

divideVenceras :: (p -> Bool)

-> (p -> s)

-> (p -> [p])

-> (p -> [s] -> s)

-> p

-> s

divideVenceras ind resuelve divide combina = dv'

where

dv' pb

| ind pb = resuelve pb

| otherwise = combina pb [dv' sp | sp <- divide pb]

ordenaPorMezcla :: Ord a => [a] -> [a]

ordenaPorMezcla =

divideVenceras ind id divide combina

where

ind xs = length xs <= 1

divide xs = [take n xs, drop n xs]

where n = length xs `div` 2

combina _ [l1,l2] = mezcla l1 l2

-- (mezcla xs ys) es la lista obtenida mezclando xs e ys. Por ejemplo,

-- mezcla [1,3] [2,4,6] == [1,2,3,4,6]

mezcla :: Ord a => [a] -> [a] -> [a]

mezcla [] b = b

mezcla a [] = a

mezcla a@(x:xs) b@(y:ys) | x <= y = x : mezcla xs b

| otherwise = y : mezcla a ys

ordenaRapida :: Ord a => [a] -> [a]

ordenaRapida =

divideVenceras ind id divide combina

where

ind xs = length xs <= 1

divide (x:xs) = [[ y | y <- xs, y <= x],

[ y | y <- xs, y > x]]

combina (x:_) [l1,l2] = l1 ++ [x] ++ l2

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

ordenaPorMezcla [3,1,4,1,5,9,2,8] `shouldBe` [1,1,2,3,4,5,8,9]

it "e2" $

ordenaRapida [3,1,4,1,5,9,2,8] `shouldBe` [1,1,2,3,4,5,8,9]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.0004 seconds

-- 2 examples, 0 failures

Soluciones en Python

from typing import Callable, TypeVar

P = TypeVar('P')
S = TypeVar('S')

def divideVenceras(ind: Callable[[P], bool],
                   resuelve: Callable[[P], S],
                   divide: Callable[[P], list[P]],
                   combina: Callable[[P, list[S]], S],
                   p: P) -> S:
    def dv(pb: P) -> S:
        if ind(pb):
            return resuelve(pb)
        return combina(pb, [dv(sp) for sp in divide(pb)])
    return dv(p)

def ordenaPorMezcla(xs: list[int]) -> list[int]:
    def ind(xs: list[int]) -> bool:
        return len(xs) <= 1

    def divide(xs: list[int]) -> list[list[int]]:
        n = len(xs) // 2
        return [xs[:n], xs[n:]]

    def combina(_: list[int], xs: list[list[int]]) -> list[int]:
        return mezcla(xs[0], xs[1])

    return divideVenceras(ind, lambda x: x, divide, combina, xs)

# (mezcla xs ys) es la lista obtenida mezclando xs e ys. Por ejemplo,
#    mezcla([1,3], [2,4,6]) == [1,2,3,4,6]
def mezcla(a: list[int], b: list[int]) -> list[int]:
    if not a:
        return b
    if not b:
        return a
    if a[0] <= b[0]:
        return [a[0]] + mezcla(a[1:], b)
    return [b[0]] + mezcla(a, b[1:])

def ordenaRapida(xs: list[int]) -> list[int]:
    def ind(xs: list[int]) -> bool:
        return len(xs) <= 1

    def divide(xs: list[int]) -> list[list[int]]:
        x, *xs = xs
        return [[y for y in xs if y <= x],
                [y for y in xs if y > x]]

    def combina(xs: list[int], ys: list[list[int]]) -> list[int]:
        x = xs[0]
        return ys[0] + [x] + ys[1]

    return divideVenceras(ind, lambda x: x, divide, combina, xs)

# Verificación
# ============

def test_divideVenceras() -> None:
    assert ordenaPorMezcla([3,1,4,1,5,9,2,8]) == [1,1,2,3,4,5,8,9]
    assert ordenaRapida([3,1,4,1,5,9,2,8]) == [1,1,2,3,4,5,8,9]
    print("Verificado")

# La verificación es
#    >>> test_divideVenceras()
#    Verificado

from typing import Callable, TypeVar

P = TypeVar('P')

S = TypeVar('S')

def divideVenceras(ind: Callable[[P], bool],

resuelve: Callable[[P], S],

divide: Callable[[P], list[P]],

combina: Callable[[P, list[S]], S],

p: P) -> S:

def dv(pb: P) -> S:

if ind(pb):

return resuelve(pb)

return combina(pb, [dv(sp) for sp in divide(pb)])

return dv(p)

def ordenaPorMezcla(xs: list[int]) -> list[int]:

def ind(xs: list[int]) -> bool:

return len(xs) <= 1

def divide(xs: list[int]) -> list[list[int]]:

n = len(xs) // 2

return [xs[:n], xs[n:]]

def combina(_: list[int], xs: list[list[int]]) -> list[int]:

return mezcla(xs[0], xs[1])

return divideVenceras(ind, lambda x: x, divide, combina, xs)

# (mezcla xs ys) es la lista obtenida mezclando xs e ys. Por ejemplo,

# mezcla([1,3], [2,4,6]) == [1,2,3,4,6]

def mezcla(a: list[int], b: list[int]) -> list[int]:

if not a:

return b

if not b:

return a

if a[0] <= b[0]:

return [a[0]] + mezcla(a[1:], b)

return [b[0]] + mezcla(a, b[1:])

def ordenaRapida(xs: list[int]) -> list[int]:

def ind(xs: list[int]) -> bool:

return len(xs) <= 1

def divide(xs: list[int]) -> list[list[int]]:

x, *xs = xs

return [[y for y in xs if y <= x],

[y for y in xs if y > x]]

def combina(xs: list[int], ys: list[list[int]]) -> list[int]:

x = xs[0]

return ys[0] + [x] + ys[1]

return divideVenceras(ind, lambda x: x, divide, combina, xs)

# Verificación

# ============

def test_divideVenceras() -> None:

assert ordenaPorMezcla([3,1,4,1,5,9,2,8]) == [1,1,2,3,4,5,8,9]

assert ordenaRapida([3,1,4,1,5,9,2,8]) == [1,1,2,3,4,5,8,9]

print("Verificado")

# La verificación es

# >>> test_divideVenceras()

# Verificado

TAD de los grafos: Algoritmo de Prim

PorJosé A. Alonso 23-junio-202316-junio-2023

El algoritmo de Prim calcula un árbol recubridor mínimo en un grafo conexo y ponderado. Es decir, busca un subconjunto de aristas que, formando un árbol, incluyen todos los vértices y donde el valor de la suma de todas las aristas del árbol es el mínimo.

El algoritmo de Prim funciona de la siguiente manera:

Inicializar un árbol con un único vértice, elegido arbitrariamente, del grafo.
Aumentar el árbol por un lado. Llamamos lado a la unión entre dos vértices: de las posibles uniones que pueden conectar el árbol a los vértices que no están aún en el árbol, encontrar el lado de menor distancia y unirlo al árbol.
Repetir el paso 2 (hasta que todos los vértices pertenezcan al árbol)

Usando el tipo abstracto de datos de los grafos, definir la función,

   prim :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

1	prim :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

tal que prim g es el árbol de expansión mínimo del grafo g calculado mediante el algoritmo de Prim. Por ejemplo, si g1, g2, g3 y g4 son los grafos definidos por

   g1, g2, g3, g4 :: Grafo Int Int
   g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                            (2,4,55),(2,5,32),
                            (3,4,61),(3,5,44),
                            (4,5,93)]
   g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),
                            (2,4,12),(2,5,32),
                            (3,4,14),(3,5,44),
                            (4,5,93)]
   g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                            (2,3,7),
                            (3,4,8),(3,5,7),
                            (4,5,5),
                            (5,6,3),(5,7,9),
                            (6,7,11)]
   g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                            (2,3,7),
                            (3,4,8),(3,5,1),
                            (4,5,5),
                            (5,6,3),(5,7,9),
                            (6,7,11)]

g1, g2, g3, g4 :: Grafo Int Int

g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),

(2,4,12),(2,5,32),

(3,4,14),(3,5,44),

(4,5,93)]

g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,7),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,1),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

entonces

   prim g1  == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
   prim g2  == [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]
   prim g3  == [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]

prim g1 == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

prim g2 == [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]

prim g3 == [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Algoritmo_de_Prim where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo, nodos)
import Data.Ix (Ix)
import Data.List (delete)
import Test.Hspec (Spec, hspec, it, shouldBe)

g1, g2, g3, g4 :: Grafo Int Int
g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                         (2,4,55),(2,5,32),
                         (3,4,61),(3,5,44),
                         (4,5,93)]
g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),
                         (2,4,12),(2,5,32),
                         (3,4,14),(3,5,44),
                         (4,5,93)]
g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                         (2,3,7),
                         (3,4,8),(3,5,7),
                         (4,5,5),
                         (5,6,3),(5,7,9),
                         (6,7,11)]
g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                         (2,3,7),
                         (3,4,8),(3,5,1),
                         (4,5,5),
                         (5,6,3),(5,7,9),
                         (6,7,11)]

prim :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]
prim g = prim' [n]              -- Nodos colocados
               ns               -- Nodos por colocar
               []               -- Árbol de expansión
               (aristas g)      -- Aristas del grafo
  where
    (n:ns) = nodos g
    prim' _ _ _  []  = []
    prim' _ [] ae _  = ae
    prim' t r  ae as = prim' (v':t) (delete v' r) (e:ae) as
      where e@(_,_, v') = minimum [(c,u,v)| ((u,v),c) <- as,
                                             u `elem` t,
                                             v `elem` r]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    prim g1 `shouldBe` [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
  it "e2" $
    prim g2 `shouldBe` [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]
  it "e3" $
    prim g3 `shouldBe` [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--
--    Finished in 0.0026 seconds
--    3 examples, 0 failures

module Grafo_Algoritmo_de_Prim where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo, nodos)

import Data.Ix (Ix)

import Data.List (delete)

import Test.Hspec (Spec, hspec, it, shouldBe)

g1, g2, g3, g4 :: Grafo Int Int

g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),

(2,4,12),(2,5,32),

(3,4,14),(3,5,44),

(4,5,93)]

g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,7),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,1),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

prim :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

prim g = prim' [n] -- Nodos colocados

ns -- Nodos por colocar

[] -- Árbol de expansión

(aristas g) -- Aristas del grafo

where

(n:ns) = nodos g

prim' _ _ _ [] = []

prim' _ [] ae _ = ae

prim' t r ae as = prim' (v':t) (delete v' r) (e:ae) as

where e@(_,_, v') = minimum [(c,u,v)| ((u,v),c) <- as,

u `elem` t,

v `elem` r]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

prim g1 `shouldBe` [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

it "e2" $

prim g2 `shouldBe` [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]

it "e3" $

prim g3 `shouldBe` [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- Finished in 0.0026 seconds

-- 3 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import (Grafo, Orientacion, Peso, Vertice, aristas,
                           creaGrafo, nodos)

g1 = creaGrafo (Orientacion.ND,
                (1,5),
                [((1,2),12),((1,3),34),((1,5),78),
                 ((2,4),55),((2,5),32),
                 ((3,4),61),((3,5),44),
                 ((4,5),93)])
g2 = creaGrafo (Orientacion.ND,
                (1,5),
                [((1,2),13),((1,3),11),((1,5),78),
                 ((2,4),12),((2,5),32),
                 ((3,4),14),((3,5),44),
                 ((4,5),93)])
g3 = creaGrafo (Orientacion.ND,
                (1,7),
                [((1,2),5),((1,3),9),((1,5),15),((1,6),6),
                 ((2,3),7),
                 ((3,4),8),((3,5),7),
                 ((4,5),5),
                 ((5,6),3),((5,7),9),
                 ((6,7),11)])
g4 = creaGrafo (Orientacion.ND,
                (1,7),
                [((1,2),5),((1,3),9),((1,5),15),((1,6),6),
                 ((2,3),7),
                 ((3,4),8),((3,5),1),
                 ((4,5),5),
                 ((5,6),3),((5,7),9),
                 ((6,7),11)])

def prim(g: Grafo) -> list[tuple[Peso, Vertice, Vertice]]:
    n, *ns = nodos(g)
    def prim_(t: list[Vertice],
              r: list[Vertice],
              ae: list[tuple[Peso, Vertice, Vertice]],
              as_: list[tuple[tuple[Vertice, Vertice], Peso]]) \
              -> list[tuple[Peso, Vertice, Vertice]]:
        if not as_:
            return []
        if not r:
            return ae
        e = min(((c,u,v)
                 for ((u,v),c) in as_
                 if u in t and v in r))
        (_,_, v_) = e
        return prim_([v_] + t, [x for x in r if x != v_], [e] + ae, as_)
    return prim_([n], ns, [], aristas(g))

# Verificación
# ============

def test_prim() -> None:
    assert prim(g1)  == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
    assert prim(g2)  == [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]
    assert prim(g3)  == [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]
    print("Verificado")

# La verificación es
#    >>> test_prim()
#    Verificado

from src.TAD.Grafo import (Grafo, Orientacion, Peso, Vertice, aristas,

creaGrafo, nodos)

g1 = creaGrafo (Orientacion.ND,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

g2 = creaGrafo (Orientacion.ND,

(1,5),

[((1,2),13),((1,3),11),((1,5),78),

((2,4),12),((2,5),32),

((3,4),14),((3,5),44),

((4,5),93)])

g3 = creaGrafo (Orientacion.ND,

(1,7),

[((1,2),5),((1,3),9),((1,5),15),((1,6),6),

((2,3),7),

((3,4),8),((3,5),7),

((4,5),5),

((5,6),3),((5,7),9),

((6,7),11)])

g4 = creaGrafo (Orientacion.ND,

(1,7),

[((1,2),5),((1,3),9),((1,5),15),((1,6),6),

((2,3),7),

((3,4),8),((3,5),1),

((4,5),5),

((5,6),3),((5,7),9),

((6,7),11)])

def prim(g: Grafo) -> list[tuple[Peso, Vertice, Vertice]]:

n, *ns = nodos(g)

def prim_(t: list[Vertice],

r: list[Vertice],

ae: list[tuple[Peso, Vertice, Vertice]],

as_: list[tuple[tuple[Vertice, Vertice], Peso]]) \

-> list[tuple[Peso, Vertice, Vertice]]:

if not as_:

return []

if not r:

return ae

e = min(((c,u,v)

for ((u,v),c) in as_

if u in t and v in r))

(_,_, v_) = e

return prim_([v_] + t, [x for x in r if x != v_], [e] + ae, as_)

return prim_([n], ns, [], aristas(g))

# Verificación

# ============

def test_prim() -> None:

assert prim(g1) == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

assert prim(g2) == [(32,2,5),(12,2,4),(13,1,2),(11,1,3)]

assert prim(g3) == [(9,5,7),(7,2,3),(5,5,4),(3,6,5),(6,1,6),(5,1,2)]

print("Verificado")

# La verificación es

# >>> test_prim()

# Verificado

TAD de los grafos: Algoritmo de Kruskal

PorJosé A. Alonso 22-junio-202316-junio-2023

El algoritmo de Kruskal calcula un árbol recubridor mínimo en un grafo conexo y ponderado. Es decir, busca un subconjunto de aristas que, formando un árbol, incluyen todos los vértices y donde el valor de la suma de todas las aristas del árbol es el mínimo.

El algoritmo de Kruskal funciona de la siguiente manera:

se crea un bosque B (un conjunto de árboles), donde cada vértice del grafo es un árbol separado
se crea un conjunto C que contenga a todas las aristas del grafo
mientras C es no vacío,
- eliminar una arista de peso mínimo de C
- si esa arista conecta dos árboles diferentes se añade al bosque, combinando los dos árboles en un solo árbol
- en caso contrario, se desecha la arista

Al acabar el algoritmo, el bosque tiene un solo componente, el cual forma un árbol de expansión mínimo del grafo.

Usando el tipo abstracto de datos de los grafos, definir la función,

   kruskal :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

1	kruskal :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

tal que kruskal g es el árbol de expansión mínimo del grafo g calculado mediante el algoritmo de Kruskal. Por ejemplo, si g1, g2, g3 y g4 son los grafos definidos por

   g1, g2, g3, g4 :: Grafo Int Int
   g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                            (2,4,55),(2,5,32),
                            (3,4,61),(3,5,44),
                            (4,5,93)]
   g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),
                            (2,4,12),(2,5,32),
                            (3,4,14),(3,5,44),
                            (4,5,93)]
   g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                            (2,3,7),
                            (3,4,8),(3,5,7),
                            (4,5,5),
                            (5,6,3),(5,7,9),
                            (6,7,11)]
   g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                            (2,3,7),
                            (3,4,8),(3,5,1),
                            (4,5,5),
                            (5,6,3),(5,7,9),
                            (6,7,11)]

g1, g2, g3, g4 :: Grafo Int Int

g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),

(2,4,12),(2,5,32),

(3,4,14),(3,5,44),

(4,5,93)]

g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,7),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,1),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

entonces

   kruskal g1  ==  [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
   kruskal g2  ==  [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]
   kruskal g3  ==  [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]
   kruskal g4  ==  [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]

kruskal g1 == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

kruskal g2 == [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]

kruskal g3 == [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]

kruskal g4 == [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Algoritmo_de_Kruskal where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo, nodos)
import Data.Ix (Ix)
import qualified Data.Map as M (Map, (!), fromList, keys, update)
import Data.List (sort)
import Test.Hspec (Spec, hspec, it, shouldBe)

g1, g2, g3, g4 :: Grafo Int Int
g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),
                         (2,4,55),(2,5,32),
                         (3,4,61),(3,5,44),
                         (4,5,93)]
g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),
                         (2,4,12),(2,5,32),
                         (3,4,14),(3,5,44),
                         (4,5,93)]
g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                         (2,3,7),
                         (3,4,8),(3,5,7),
                         (4,5,5),
                         (5,6,3),(5,7,9),
                         (6,7,11)]
g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),
                         (2,3,7),
                         (3,4,8),(3,5,1),
                         (4,5,5),
                         (5,6,3),(5,7,9),
                         (6,7,11)]

kruskal :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]
kruskal g = aux (sort [(p,x,y) | ((x,y),p) <- aristas g])
                (M.fromList [(x,x) | x <- nodos g])
                []
                (length (nodos g) - 1)
  where aux _  _ ae 0 = ae
        aux [] _ _  _ = error "Imposible"
        aux ((p,x,y):as) d ae n
          | actualizado = aux as d' ((p,x,y):ae) (n-1)
          | otherwise   = aux as d ae n
          where (actualizado,d') = buscaActualiza (x,y) d

-- (raiz d n) es la raíz de n en el diccionario. Por ejemplo,
--    raiz (M.fromList [(1,1),(3,1),(4,3),(5,4),(2,6),(6,6)]) 5  == 1
--    raiz (M.fromList [(1,1),(3,1),(4,3),(5,4),(2,6),(6,6)]) 2  == 6
raiz :: (Eq n, Ord n) => M.Map n n -> n -> n
raiz d x | v == x    = v
         | otherwise = raiz d v
  where v = d M.! x

-- (buscaActualiza a d) es el par formado por False y el diccionario d,
-- si los dos vértices de la arista a tienen la misma raíz en d y el par
-- formado por True y la tabla obtenida añadiéndole a d la arista
-- formada por el vértice de a de mayor raíz y la raíz del vértice de a
-- de menor raíz. Y actualizando las raices de todos los elementos
-- afectados por la raíz añadida. Por ejemplo,
--   λ> d = M.fromList [(1,1),(2,1),(3,3),(4,4),(5,5),(6,5),(7,7)]
--   λ> buscaActualiza (5,4) d
--   (True,fromList [(1,1),(2,1),(3,3),(4,4),(5,4),(6,4),(7,7)])
--   λ> d' = snd it
--   λ> buscaActualiza (6,1) d'
--   (True,fromList [(1,1),(2,1),(3,3),(4,1),(5,1),(6,1),(7,7)])
buscaActualiza :: (Eq n, Ord n) => (n,n) -> M.Map n n -> (Bool,M.Map n n)
buscaActualiza (x,y) d
  | x' == y'  = (False, d)
  | y' <  x'  = (True, modificaR x (d M.! x) y' d)
  | otherwise = (True, modificaR y (d M.! y) x' d)
  where x' = raiz d x
        y' = raiz d y

-- (modificaR x y y' d) actualiza d como sigue:
-- + el valor de todas las claves z con valor y es y'
-- + el valor de todas las claves z con (z > x) con valor x es y'
modificaR :: (Eq n, Ord n) => n -> n -> n -> M.Map n n -> M.Map n n
modificaR x y y' d = aux2 ds (aux1 cs d)
  where cs = M.keys d
        ds = filter (>x) cs
        aux1 [] tb = tb
        aux1 (a:as) tb | tb M.! a == y = aux1 as (M.update (\_ -> Just y') a tb)
                       | otherwise     = aux1 as tb
        aux2 [] tb = tb
        aux2 (b:bs) tb | tb M.! b == x = aux2 bs (M.update (\_ -> Just y') b tb)
                       | otherwise     = aux2 bs tb

-- Traza del diccionario correspondiente al grafo g3
-- =================================================

-- Lista de aristas, ordenadas según su peso:
-- [(3,5,6),(5,1,2),(5,4,5),(6,1,6),(7,2,3),(7,3,5),(8,3,4),(9,1,3),(9,5,7),(11,6,7),(15,1,5)]
--
-- Inicial
--   fromList [(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7)]
--
-- Después de añadir la arista (5,6) de peso 3
--   fromList [(1,1),(2,2),(3,3),(4,4),(5,5),(6,5),(7,7)]
--
-- Después de añadir la arista (1,2) de peso 5
--   fromList [(1,1),(2,1),(3,3),(4,4),(5,5),(6,5),(7,7)]
--
-- Después de añadir la arista (4,5) de peso 5
--   fromList [(1,1),(2,1),(3,3),(4,4),(5,4),(6,4),(7,7)]
--
-- Después de añadir la arista (1,6) de peso 6
--   fromList [(1,1),(2,1),(3,3),(4,1),(5,1),(6,1),(7,7)]
--
-- Después de añadir la arista (2,3) de peso 7
--   fromList [(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,7)]
--
-- Las posibles aristas a añadir son:
-- + la (3,5) con peso 7, que no es posible pues la raíz de 3
--   coincide con la raíz de 5, por lo que formaría un ciclo
-- + la (3,4) con peso 8, que no es posible pues la raíz de 3
--   coincide con la raíz de 4, por lo que formaría un ciclo
-- + la (1,3) con peso 9, que no es posible pues la raíz de 3
--   coincide con la raíz de 1, por lo que formaría un ciclo
-- + la (5,7) con peso 9, que no forma ciclo
--
-- Después de añadir la arista (5,7) con peso 9
--    fromList [(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1)]
--
-- No es posible añadir más aristas, pues formarían ciclos.

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    kruskal g1 `shouldBe` [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
  it "e2" $
    kruskal g2 `shouldBe` [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]
  it "e3" $
    kruskal g3 `shouldBe` [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]
  it "e4" $
    kruskal g4 `shouldBe` [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--
--    Finished in 0.0044 seconds
--    4 examples, 0 failures

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

module Grafo_Algoritmo_de_Kruskal where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo, nodos)

import Data.Ix (Ix)

import qualified Data.Map as M (Map, (!), fromList, keys, update)

import Data.List (sort)

import Test.Hspec (Spec, hspec, it, shouldBe)

g1, g2, g3, g4 :: Grafo Int Int

g1 = creaGrafo ND (1,5) [(1,2,12),(1,3,34),(1,5,78),

(2,4,55),(2,5,32),

(3,4,61),(3,5,44),

(4,5,93)]

g2 = creaGrafo ND (1,5) [(1,2,13),(1,3,11),(1,5,78),

(2,4,12),(2,5,32),

(3,4,14),(3,5,44),

(4,5,93)]

g3 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,7),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

g4 = creaGrafo ND (1,7) [(1,2,5),(1,3,9),(1,5,15),(1,6,6),

(2,3,7),

(3,4,8),(3,5,1),

(4,5,5),

(5,6,3),(5,7,9),

(6,7,11)]

kruskal :: (Ix v, Num p, Ord p) => Grafo v p -> [(p,v,v)]

kruskal g = aux (sort [(p,x,y) | ((x,y),p) <- aristas g])

(M.fromList [(x,x) | x <- nodos g])

[]

(length (nodos g) - 1)

where aux _ _ ae 0 = ae

aux [] _ _ _ = error "Imposible"

aux ((p,x,y):as) d ae n

| actualizado = aux as d' ((p,x,y):ae) (n-1)

| otherwise = aux as d ae n

where (actualizado,d') = buscaActualiza (x,y) d

-- (raiz d n) es la raíz de n en el diccionario. Por ejemplo,

-- raiz (M.fromList [(1,1),(3,1),(4,3),(5,4),(2,6),(6,6)]) 5 == 1

-- raiz (M.fromList [(1,1),(3,1),(4,3),(5,4),(2,6),(6,6)]) 2 == 6

raiz :: (Eq n, Ord n) => M.Map n n -> n -> n

raiz d x | v == x = v

| otherwise = raiz d v

where v = d M.! x

-- (buscaActualiza a d) es el par formado por False y el diccionario d,

-- si los dos vértices de la arista a tienen la misma raíz en d y el par

-- formado por True y la tabla obtenida añadiéndole a d la arista

-- formada por el vértice de a de mayor raíz y la raíz del vértice de a

-- de menor raíz. Y actualizando las raices de todos los elementos

-- afectados por la raíz añadida. Por ejemplo,

-- λ> d = M.fromList [(1,1),(2,1),(3,3),(4,4),(5,5),(6,5),(7,7)]

-- λ> buscaActualiza (5,4) d

-- (True,fromList [(1,1),(2,1),(3,3),(4,4),(5,4),(6,4),(7,7)])

-- λ> d' = snd it

-- λ> buscaActualiza (6,1) d'

-- (True,fromList [(1,1),(2,1),(3,3),(4,1),(5,1),(6,1),(7,7)])

buscaActualiza :: (Eq n, Ord n) => (n,n) -> M.Map n n -> (Bool,M.Map n n)

buscaActualiza (x,y) d

| x' == y' = (False, d)

| y' < x' = (True, modificaR x (d M.! x) y' d)

| otherwise = (True, modificaR y (d M.! y) x' d)

where x' = raiz d x

y' = raiz d y

-- (modificaR x y y' d) actualiza d como sigue:

-- + el valor de todas las claves z con valor y es y'

-- + el valor de todas las claves z con (z > x) con valor x es y'

modificaR :: (Eq n, Ord n) => n -> n -> n -> M.Map n n -> M.Map n n

modificaR x y y' d = aux2 ds (aux1 cs d)

where cs = M.keys d

ds = filter (>x) cs

aux1 [] tb = tb

aux1 (a:as) tb | tb M.! a == y = aux1 as (M.update (\_ -> Just y') a tb)

| otherwise = aux1 as tb

aux2 [] tb = tb

aux2 (b:bs) tb | tb M.! b == x = aux2 bs (M.update (\_ -> Just y') b tb)

| otherwise = aux2 bs tb

-- Traza del diccionario correspondiente al grafo g3

-- =================================================

-- Lista de aristas, ordenadas según su peso:

-- [(3,5,6),(5,1,2),(5,4,5),(6,1,6),(7,2,3),(7,3,5),(8,3,4),(9,1,3),(9,5,7),(11,6,7),(15,1,5)]

-- Inicial

-- fromList [(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7)]

-- Después de añadir la arista (5,6) de peso 3

-- fromList [(1,1),(2,2),(3,3),(4,4),(5,5),(6,5),(7,7)]

-- Después de añadir la arista (1,2) de peso 5

-- fromList [(1,1),(2,1),(3,3),(4,4),(5,5),(6,5),(7,7)]

-- Después de añadir la arista (4,5) de peso 5

-- fromList [(1,1),(2,1),(3,3),(4,4),(5,4),(6,4),(7,7)]

-- Después de añadir la arista (1,6) de peso 6

-- fromList [(1,1),(2,1),(3,3),(4,1),(5,1),(6,1),(7,7)]

-- Después de añadir la arista (2,3) de peso 7

-- fromList [(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,7)]

-- Las posibles aristas a añadir son:

-- + la (3,5) con peso 7, que no es posible pues la raíz de 3

-- coincide con la raíz de 5, por lo que formaría un ciclo

-- + la (3,4) con peso 8, que no es posible pues la raíz de 3

-- coincide con la raíz de 4, por lo que formaría un ciclo

-- + la (1,3) con peso 9, que no es posible pues la raíz de 3

-- coincide con la raíz de 1, por lo que formaría un ciclo

-- + la (5,7) con peso 9, que no forma ciclo

-- Después de añadir la arista (5,7) con peso 9

-- fromList [(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1)]

-- No es posible añadir más aristas, pues formarían ciclos.

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

kruskal g1 `shouldBe` [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

it "e2" $

kruskal g2 `shouldBe` [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]

it "e3" $

kruskal g3 `shouldBe` [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]

it "e4" $

kruskal g4 `shouldBe` [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- Finished in 0.0044 seconds

-- 4 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import (Grafo, Orientacion, Peso, Vertice, aristas,
                           creaGrafo, nodos)

g1 = creaGrafo (Orientacion.ND,
                (1,5),
                [((1,2),12),((1,3),34),((1,5),78),
                 ((2,4),55),((2,5),32),
                 ((3,4),61),((3,5),44),
                 ((4,5),93)])
g2 = creaGrafo (Orientacion.ND,
                (1,5),
                [((1,2),13),((1,3),11),((1,5),78),
                 ((2,4),12),((2,5),32),
                 ((3,4),14),((3,5),44),
                 ((4,5),93)])
g3 = creaGrafo (Orientacion.ND,
                (1,7),
                [((1,2),5),((1,3),9),((1,5),15),((1,6),6),
                 ((2,3),7),
                 ((3,4),8),((3,5),7),
                 ((4,5),5),
                 ((5,6),3),((5,7),9),
                 ((6,7),11)])
g4 = creaGrafo (Orientacion.ND,
                (1,7),
                [((1,2),5),((1,3),9),((1,5),15),((1,6),6),
                 ((2,3),7),
                 ((3,4),8),((3,5),1),
                 ((4,5),5),
                 ((5,6),3),((5,7),9),
                 ((6,7),11)])

# raiz(d, n) es la raíz de n en el diccionario. Por ejemplo,
#    raiz({1:1, 3:1, 4:3, 5:4, 2:6, 6:6}, 5)  == 1
#    raiz({1:1, 3:1, 4:3, 5:4, 2:6, 6:6}, 2)  == 6
def raiz(d: dict[Vertice, Vertice], x: Vertice) -> Vertice:
    v = d[x]
    if v == x:
        return v
    return raiz(d, v)

# modificaR(x, y, y_, d) actualiza d como sigue:
# + el valor de todas las claves z con valor y es y_
# + el valor de todas las claves z con (z > x) con valor x es y_
def modificaR(x: Vertice,
              y: Vertice,
              y_: Vertice,
              d: dict[Vertice, Vertice]) -> dict[Vertice, Vertice]:
    def aux1(vs: list[Vertice],
             tb: dict[Vertice, Vertice],
             y: Vertice) -> dict[Vertice, Vertice]:
        for a in vs:
            if tb[a] == y:
                tb[a] = y_
        return tb

    def aux2(vs: list[Vertice],
             tb: dict[Vertice, Vertice],
             y_: Vertice) -> dict[Vertice, Vertice]:
        for b in vs:
            if tb[b] == x:
                tb[b] = y_
        return tb

    cs = list(d.keys())
    ds = [c for c in cs if c > x]

    tb = aux1(cs, d, y)
    tb = aux2(ds, tb, y_)

    return tb

# buscaActualiza(a, d) es el par formado por False y el diccionario d,
# si los dos vértices de la arista a tienen la misma raíz en d y el par
# formado por True y la tabla obtenida añadiéndole a d la arista
# formada por el vértice de a de mayor raíz y la raíz del vértice de a
# de menor raíz. Y actualizando las raices de todos los elementos
# afectados por la raíz añadida. Por ejemplo,
#    >>> buscaActualiza((5,4), {1:1, 2:1, 3:3, 4:4, 5:5, 6:5, 7:7})
#    (True, {1: 1, 2: 1, 3: 3, 4: 4, 5: 4, 6: 4, 7: 7})
#    >>> buscaActualiza((6,1), {1:1, 2:1, 3:3, 4:4, 5:4, 6:4, 7:7})
#    (True, {1: 1, 2: 1, 3: 3, 4: 1, 5: 1, 6: 1, 7: 7})
#    >>> buscaActualiza((6,2), {1:1, 2:1, 3:3, 4:1, 5:4, 6:5, 7:7})
#    (False, {1: 1, 2: 1, 3: 3, 4: 1, 5: 4, 6: 5, 7: 7})
def buscaActualiza(a: tuple[Vertice, Vertice],
                   d: dict[Vertice, Vertice]) -> tuple[bool,
                                                       dict[Vertice, Vertice]]:
    x, y = a
    x_ = raiz(d, x)
    y_ = raiz(d, y)

    if x_ == y_:
        return False, d
    if y_ < x_:
        return True, modificaR(x, d[x], y_, d)
    return True, modificaR(y, d[y], x_, d)

def kruskal(g: Grafo) -> list[tuple[Peso, Vertice, Vertice]]:
    def aux(as_: list[tuple[Peso, Vertice, Vertice]],
            d: dict[Vertice, Vertice],
            ae: list[tuple[Peso, Vertice, Vertice]],
            n: int) -> list[tuple[Peso, Vertice, Vertice]]:
        if n == 0:
            return ae
        p, x, y = as_[0]
        actualizado, d = buscaActualiza((x, y), d)
        if actualizado:
            return aux(as_[1:], d, [(p, x, y)] + ae, n - 1)
        return aux(as_[1:], d, ae, n)
    return aux(list(sorted([(p, x, y) for ((x, y), p) in aristas(g)])),
               {x: x for x in nodos(g)},
               [],
               len(nodos(g)) - 1)

# Traza del diccionario correspondiente al grafo g3
# =================================================

# Lista de aristas, ordenadas según su peso:
# [(3,5,6),(5,1,2),(5,4,5),(6,1,6),(7,2,3),(7,3,5),(8,3,4),(9,1,3),(9,5,7),(11,6,7),(15,1,5)]
#
# Inicial
#   {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7}
#
# Después de añadir la arista (5,6) de peso 3
#   {1:1, 2:2, 3:3, 4:4, 5:5, 6:5, 7:7}
#
# Después de añadir la arista (1,2) de peso 5
#   {1:1, 2:1, 3:3, 4:4, 5:5, 6:5, 7:7}
#
# Después de añadir la arista (4,5) de peso 5
#   {1:1, 2:1, 3:3, 4:4, 5:4, 6:4, 7:7}
#
# Después de añadir la arista (1,6) de peso 6
#   {1:1, 2:1, 3:3, 4:1, 5:1, 6:1, 7:7}
#
# Después de añadir la arista (2,3) de peso 7
#   {1:1, 2:1, 3:1, 4:1, 5:1, 6:1, 7:7}
#
# Las posibles aristas a añadir son:
# + la (3,5) con peso 7, que no es posible pues la raíz de 3
#   coincide con la raíz de 5, por lo que formaría un ciclo
# + la (3,4) con peso 8, que no es posible pues la raíz de 3
#   coincide con la raíz de 4, por lo que formaría un ciclo
# + la (1,3) con peso 9, que no es posible pues la raíz de 3
#   coincide con la raíz de 1, por lo que formaría un ciclo
# + la (5,7) con peso 9, que no forma ciclo
#
# Después de añadir la arista (5,7) con peso 9
#    {1:1, 2:1, 3:1, 4:1, 5:1, 6:1, 7:1}
#
# No es posible añadir más aristas, pues formarían ciclos.

# Verificación
# ============

def test_kruskal() -> None:
    assert kruskal(g1) == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]
    assert kruskal(g2) == [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]
    assert kruskal(g3) == [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]
    assert kruskal(g4) == [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]
    print("Vefificado")

# La verificación es
#    >>> test_kruskal()
#    Vefificado

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

from src.TAD.Grafo import (Grafo, Orientacion, Peso, Vertice, aristas,

creaGrafo, nodos)

g1 = creaGrafo (Orientacion.ND,

(1,5),

[((1,2),12),((1,3),34),((1,5),78),

((2,4),55),((2,5),32),

((3,4),61),((3,5),44),

((4,5),93)])

g2 = creaGrafo (Orientacion.ND,

(1,5),

[((1,2),13),((1,3),11),((1,5),78),

((2,4),12),((2,5),32),

((3,4),14),((3,5),44),

((4,5),93)])

g3 = creaGrafo (Orientacion.ND,

(1,7),

[((1,2),5),((1,3),9),((1,5),15),((1,6),6),

((2,3),7),

((3,4),8),((3,5),7),

((4,5),5),

((5,6),3),((5,7),9),

((6,7),11)])

g4 = creaGrafo (Orientacion.ND,

(1,7),

[((1,2),5),((1,3),9),((1,5),15),((1,6),6),

((2,3),7),

((3,4),8),((3,5),1),

((4,5),5),

((5,6),3),((5,7),9),

((6,7),11)])

# raiz(d, n) es la raíz de n en el diccionario. Por ejemplo,

# raiz({1:1, 3:1, 4:3, 5:4, 2:6, 6:6}, 5) == 1

# raiz({1:1, 3:1, 4:3, 5:4, 2:6, 6:6}, 2) == 6

def raiz(d: dict[Vertice, Vertice], x: Vertice) -> Vertice:

v = d[x]

if v == x:

return v

return raiz(d, v)

# modificaR(x, y, y_, d) actualiza d como sigue:

# + el valor de todas las claves z con valor y es y_

# + el valor de todas las claves z con (z > x) con valor x es y_

def modificaR(x: Vertice,

y: Vertice,

y_: Vertice,

d: dict[Vertice, Vertice]) -> dict[Vertice, Vertice]:

def aux1(vs: list[Vertice],

tb: dict[Vertice, Vertice],

y: Vertice) -> dict[Vertice, Vertice]:

for a in vs:

if tb[a] == y:

tb[a] = y_

return tb

def aux2(vs: list[Vertice],

tb: dict[Vertice, Vertice],

y_: Vertice) -> dict[Vertice, Vertice]:

for b in vs:

if tb[b] == x:

tb[b] = y_

return tb

cs = list(d.keys())

ds = [c for c in cs if c > x]

tb = aux1(cs, d, y)

tb = aux2(ds, tb, y_)

return tb

# buscaActualiza(a, d) es el par formado por False y el diccionario d,

# si los dos vértices de la arista a tienen la misma raíz en d y el par

# formado por True y la tabla obtenida añadiéndole a d la arista

# formada por el vértice de a de mayor raíz y la raíz del vértice de a

# de menor raíz. Y actualizando las raices de todos los elementos

# afectados por la raíz añadida. Por ejemplo,

# >>> buscaActualiza((5,4), {1:1, 2:1, 3:3, 4:4, 5:5, 6:5, 7:7})

# (True, {1: 1, 2: 1, 3: 3, 4: 4, 5: 4, 6: 4, 7: 7})

# >>> buscaActualiza((6,1), {1:1, 2:1, 3:3, 4:4, 5:4, 6:4, 7:7})

# (True, {1: 1, 2: 1, 3: 3, 4: 1, 5: 1, 6: 1, 7: 7})

# >>> buscaActualiza((6,2), {1:1, 2:1, 3:3, 4:1, 5:4, 6:5, 7:7})

# (False, {1: 1, 2: 1, 3: 3, 4: 1, 5: 4, 6: 5, 7: 7})

def buscaActualiza(a: tuple[Vertice, Vertice],

d: dict[Vertice, Vertice]) -> tuple[bool,

dict[Vertice, Vertice]]:

x, y = a

x_ = raiz(d, x)

y_ = raiz(d, y)

if x_ == y_:

return False, d

if y_ < x_:

return True, modificaR(x, d[x], y_, d)

return True, modificaR(y, d[y], x_, d)

def kruskal(g: Grafo) -> list[tuple[Peso, Vertice, Vertice]]:

def aux(as_: list[tuple[Peso, Vertice, Vertice]],

d: dict[Vertice, Vertice],

ae: list[tuple[Peso, Vertice, Vertice]],

n: int) -> list[tuple[Peso, Vertice, Vertice]]:

if n == 0:

return ae

p, x, y = as_[0]

actualizado, d = buscaActualiza((x, y), d)

if actualizado:

return aux(as_[1:], d, [(p, x, y)] + ae, n - 1)

return aux(as_[1:], d, ae, n)

return aux(list(sorted([(p, x, y) for ((x, y), p) in aristas(g)])),

{x: x for x in nodos(g)},

[],

len(nodos(g)) - 1)

# Traza del diccionario correspondiente al grafo g3

# =================================================

# Lista de aristas, ordenadas según su peso:

# [(3,5,6),(5,1,2),(5,4,5),(6,1,6),(7,2,3),(7,3,5),(8,3,4),(9,1,3),(9,5,7),(11,6,7),(15,1,5)]

# Inicial

# {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7}

# Después de añadir la arista (5,6) de peso 3

# {1:1, 2:2, 3:3, 4:4, 5:5, 6:5, 7:7}

# Después de añadir la arista (1,2) de peso 5

# {1:1, 2:1, 3:3, 4:4, 5:5, 6:5, 7:7}

# Después de añadir la arista (4,5) de peso 5

# {1:1, 2:1, 3:3, 4:4, 5:4, 6:4, 7:7}

# Después de añadir la arista (1,6) de peso 6

# {1:1, 2:1, 3:3, 4:1, 5:1, 6:1, 7:7}

# Después de añadir la arista (2,3) de peso 7

# {1:1, 2:1, 3:1, 4:1, 5:1, 6:1, 7:7}

# Las posibles aristas a añadir son:

# + la (3,5) con peso 7, que no es posible pues la raíz de 3

# coincide con la raíz de 5, por lo que formaría un ciclo

# + la (3,4) con peso 8, que no es posible pues la raíz de 3

# coincide con la raíz de 4, por lo que formaría un ciclo

# + la (1,3) con peso 9, que no es posible pues la raíz de 3

# coincide con la raíz de 1, por lo que formaría un ciclo

# + la (5,7) con peso 9, que no forma ciclo

# Después de añadir la arista (5,7) con peso 9

# {1:1, 2:1, 3:1, 4:1, 5:1, 6:1, 7:1}

# No es posible añadir más aristas, pues formarían ciclos.

# Verificación

# ============

def test_kruskal() -> None:

assert kruskal(g1) == [(55,2,4),(34,1,3),(32,2,5),(12,1,2)]

assert kruskal(g2) == [(32,2,5),(13,1,2),(12,2,4),(11,1,3)]

assert kruskal(g3) == [(9,5,7),(7,2,3),(6,1,6),(5,4,5),(5,1,2),(3,5,6)]

assert kruskal(g4) == [(9,5,7),(6,1,6),(5,4,5),(5,1,2),(3,5,6),(1,3,5)]

print("Vefificado")

# La verificación es

# >>> test_kruskal()

# Vefificado

TAD de los grafos: Nodos conectados en un grafo

PorJosé A. Alonso 21-junio-202314-junio-2023

Usando el tipo abstracto de datos de los grafos, definir la función,

   conectados :: Grafo Int Int -> Int -> Int -> Bool

1	conectados :: Grafo Int Int -> Int -> Int -> Bool

tal que conectados g v1 v2 se verifica si los vértices v1 y v2 están conectados en el grafo g. Por ejemplo, si grafo1 es el grafo definido por

   grafo1 :: Grafo Int Int
   grafo1 = creaGrafo' D (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),
                                (2,4),(2,6),(4,6),(4,4),(6,4)]

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),

(2,4),(2,6),(4,6),(4,4),(6,4)]

entonces,

   conectados grafo1 1 3  ==  True
   conectados grafo1 1 4  ==  False
   conectados grafo1 6 2  ==  False
   conectados grafo1 3 1  ==  True

conectados grafo1 1 3 == True

conectados grafo1 1 4 == False

conectados grafo1 6 2 == False

conectados grafo1 3 1 == True

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Nodos_conectados_en_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')
import Data.List (union)
import Test.Hspec (Spec, hspec, it, shouldBe)

conectados :: Grafo Int Int -> Int -> Int -> Bool
conectados g v1 v2 = v2 `elem` conectadosAux g [] [v1]

conectadosAux :: Grafo Int Int -> [Int] -> [Int] -> [Int]
conectadosAux _ vs [] = vs
conectadosAux g vs (w:ws)
  | w `elem` vs = conectadosAux g vs ws
  | otherwise = conectadosAux g ([w] `union` vs) (ws `union` adyacentes g w)

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    conectados grafo1 1 3  `shouldBe`  True
  it "e2" $
    conectados grafo1 1 4  `shouldBe`  False
  it "e3" $
    conectados grafo1 6 2  `shouldBe`  False
  it "e4" $
    conectados grafo1 3 1  `shouldBe`  True
  it "e5" $
    conectados grafo2 1 3  `shouldBe`  True
  it "e6" $
    conectados grafo2 1 4  `shouldBe`  False
  it "e7" $
    conectados grafo2 6 2  `shouldBe`  True
  it "e8" $
    conectados grafo2 3 1  `shouldBe`  True
  where
    grafo1, grafo2 :: Grafo Int Int
    grafo1 = creaGrafo' D (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),
                                 (2,4),(2,6),(4,6),(4,4),(6,4)]

    grafo2 = creaGrafo' ND (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),
                                  (2,4),(2,6),(4,6),(4,4),(6,4)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--    e5
--    e6
--    e7
--    e8
--
--    Finished in 0.0032 seconds
--    8 examples, 0 failures

module Grafo_Nodos_conectados_en_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')

import Data.List (union)

import Test.Hspec (Spec, hspec, it, shouldBe)

conectados :: Grafo Int Int -> Int -> Int -> Bool

conectados g v1 v2 = v2 `elem` conectadosAux g [] [v1]

conectadosAux :: Grafo Int Int -> [Int] -> [Int] -> [Int]

conectadosAux _ vs [] = vs

conectadosAux g vs (w:ws)

| w `elem` vs = conectadosAux g vs ws

| otherwise = conectadosAux g ([w] `union` vs) (ws `union` adyacentes g w)

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

conectados grafo1 1 3 `shouldBe` True

it "e2" $

conectados grafo1 1 4 `shouldBe` False

it "e3" $

conectados grafo1 6 2 `shouldBe` False

it "e4" $

conectados grafo1 3 1 `shouldBe` True

it "e5" $

conectados grafo2 1 3 `shouldBe` True

it "e6" $

conectados grafo2 1 4 `shouldBe` False

it "e7" $

conectados grafo2 6 2 `shouldBe` True

it "e8" $

conectados grafo2 3 1 `shouldBe` True

where

grafo1, grafo2 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),

(2,4),(2,6),(4,6),(4,4),(6,4)]

grafo2 = creaGrafo' ND (1,6) [(1,3),(1,5),(3,5),(5,1),(5,50),

(2,4),(2,6),(4,6),(4,4),(6,4)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- e7

-- e8

-- Finished in 0.0032 seconds

-- 8 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_


def unionV(xs: list[Vertice], ys: list[Vertice]) -> list[Vertice]:
    return list(set(xs) | set(ys))

def conectadosAux(g: Grafo, vs: list[Vertice], ws: list[Vertice]) -> list[Vertice]:
    if not ws:
        return vs
    w, *ws = ws
    if w in vs:
        return conectadosAux(g, vs, ws)
    return conectadosAux(g, unionV([w], vs), unionV(ws, adyacentes(g, w)))

def conectados(g: Grafo, v1: Vertice, v2: Vertice) -> bool:
    return v2 in conectadosAux(g, [], [v1])


# Verificación
# ============

def test_conectados() -> None:
    grafo1 = creaGrafo_(Orientacion.D,
                        (1,6),
                        [(1,3),(1,5),(3,5),(5,1),(5,50),
                         (2,4),(2,6),(4,6),(4,4),(6,4)])
    grafo2 = creaGrafo_(Orientacion.ND,
                        (1,6),
                        [(1,3),(1,5),(3,5),(5,1),(5,50),
                         (2,4),(2,6),(4,6),(4,4),(6,4)])
    assert conectados(grafo1, 1, 3)
    assert not conectados(grafo1, 1, 4)
    assert not conectados(grafo1, 6, 2)
    assert conectados(grafo1, 3, 1)
    assert conectados(grafo2, 1, 3)
    assert not conectados(grafo2, 1, 4)
    assert conectados(grafo2, 6, 2)
    assert conectados(grafo2, 3, 1)
    print("Verificado")

# La verificación es
#    >>> test_conectados()
#    Verificado

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

def unionV(xs: list[Vertice], ys: list[Vertice]) -> list[Vertice]:

return list(set(xs) | set(ys))

def conectadosAux(g: Grafo, vs: list[Vertice], ws: list[Vertice]) -> list[Vertice]:

if not ws:

return vs

w, *ws = ws

if w in vs:

return conectadosAux(g, vs, ws)

return conectadosAux(g, unionV([w], vs), unionV(ws, adyacentes(g, w)))

def conectados(g: Grafo, v1: Vertice, v2: Vertice) -> bool:

return v2 in conectadosAux(g, [], [v1])

# Verificación

# ============

def test_conectados() -> None:

grafo1 = creaGrafo_(Orientacion.D,

(1,6),

[(1,3),(1,5),(3,5),(5,1),(5,50),

(2,4),(2,6),(4,6),(4,4),(6,4)])

grafo2 = creaGrafo_(Orientacion.ND,

(1,6),

[(1,3),(1,5),(3,5),(5,1),(5,50),

(2,4),(2,6),(4,6),(4,4),(6,4)])

assert conectados(grafo1, 1, 3)

assert not conectados(grafo1, 1, 4)

assert not conectados(grafo1, 6, 2)

assert conectados(grafo1, 3, 1)

assert conectados(grafo2, 1, 3)

assert not conectados(grafo2, 1, 4)

assert conectados(grafo2, 6, 2)

assert conectados(grafo2, 3, 1)

print("Verificado")

# La verificación es

# >>> test_conectados()

# Verificado

TAD de los grafos: Nodos aislados de un grafo

PorJosé A. Alonso 20-junio-202312-junio-2023

Dado un grafo dirigido G, diremos que un nodo está aislado si o bien de dicho nodo no sale ninguna arista o bien no llega al nodo ninguna arista. Por ejemplo, en el siguiente grafo

   grafo1 :: Grafo Int Int
   grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),
                                (5,4),(6,2),(6,5)]

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),

(5,4),(6,2),(6,5)]

podemos ver que del nodo 1 salen 3 aristas pero no llega ninguna, por lo que lo consideramos aislado. Así mismo, a los nodos 2 y 4 llegan aristas pero no sale ninguna, por tanto también estarán aislados.

Usando el tipo abstracto de datos de los grafos, definir la función,

   aislados :: (Ix v, Num p) => Grafo v p -> [v]

1	aislados :: (Ix v, Num p) => Grafo v p -> [v]

tal que aislados g es la lista de nodos aislados del grafo g. Por ejemplo,

   aislados grafo1 == [1,2,4]

1	aislados grafo1 == [1,2,4]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Nodos_aislados_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D), adyacentes, nodos, creaGrafo')
import Data.Ix (Ix)
import Grafo_Incidentes_de_un_vertice (incidentes)
import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int
grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),
                             (5,4),(6,2),(6,5)]

aislados :: (Ix v, Num p) => Grafo v p -> [v]
aislados g =
  [n | n <- nodos g, null (adyacentes g n) || null (incidentes g n)]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    aislados grafo1 `shouldBe` [1,2,4]

-- La verificación es
--    λ> verifica
--
--    e1
--
--    Finished in 0.0008 seconds
--    1 example, 0 failures

module Grafo_Nodos_aislados_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D), adyacentes, nodos, creaGrafo')

import Data.Ix (Ix)

import Grafo_Incidentes_de_un_vertice (incidentes)

import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),

(5,4),(6,2),(6,5)]

aislados :: (Ix v, Num p) => Grafo v p -> [v]

aislados g =

[n | n <- nodos g, null (adyacentes g n) || null (incidentes g n)]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

aislados grafo1 `shouldBe` [1,2,4]

-- La verificación es

-- λ> verifica

-- e1

-- Finished in 0.0008 seconds

-- 1 example, 0 failures

Soluciones en Python

from src.Grafo_Incidentes_de_un_vertice import incidentes
from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, creaGrafo_,
                           nodos)

grafo1: Grafo = creaGrafo_(Orientacion.D,
                           (1,6),
                           [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

def aislados(g: Grafo) -> list[Vertice]:
    return [n for n in nodos(g)
            if not adyacentes(g, n) or not incidentes(g, n)]

# Verificación
# ============

def test_aislados() -> None:
    assert aislados(grafo1) == [1, 2, 4]
    print("Verificado")

# La verificación es
#    >>> test_aislados()
#    Verificado

from src.Grafo_Incidentes_de_un_vertice import incidentes

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, creaGrafo_,

nodos)

grafo1: Grafo = creaGrafo_(Orientacion.D,

(1,6),

[(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

def aislados(g: Grafo) -> list[Vertice]:

return [n for n in nodos(g)

if not adyacentes(g, n) or not incidentes(g, n)]

# Verificación

# ============

def test_aislados() -> None:

assert aislados(grafo1) == [1, 2, 4]

print("Verificado")

# La verificación es

# >>> test_aislados()

# Verificado

TAD de los grafos: Coloreado correcto de un mapa

PorJosé A. Alonso 19-junio-202312-junio-2023

Un mapa se puede representar mediante un grafo donde los vértices son las regiones del mapa y hay una arista entre dos vértices si las correspondientes regiones son vecinas. Por ejemplo, el mapa siguiente

   +----------+----------+
   |    1     |     2    |
   +----+-----+-----+----+
   |    |           |    |
   | 3  |     4     | 5  |
   |    |           |    |
   +----+-----+-----+----+
   |    6     |     7    |
   +----------+----------+

+----------+----------+

| 1 | 2 |

+----+-----+-----+----+

| | | |

| 3 | 4 | 5 |

| | | |

+----+-----+-----+----+

| 6 | 7 |

+----------+----------+

se pueden representar por

   mapa :: Grafo Int Int
   mapa = creaGrafo' ND (1,7)
                     [(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),
                      (3,6),(4,5),(4,6),(4,7),(5,7),(6,7)]

mapa :: Grafo Int Int

mapa = creaGrafo' ND (1,7)

[(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),

(3,6),(4,5),(4,6),(4,7),(5,7),(6,7)]

Para colorear el mapa se dispone de 4 colores definidos por

   data Color = A | B | C | D
     deriving (Eq, Show)

1 2	data Color = A \| B \| C \| D deriving (Eq, Show)

Usando el tipo abstracto de datos de los grafos, definir la función,

   correcta :: [(Int,Color)] -> Grafo Int Int -> Bool

1	correcta :: [(Int,Color)] -> Grafo Int Int -> Bool

tal que correcta ncs m se verifica si ncs es una coloración del mapa m tal que todos las regiones vecinas tienen colores distintos. Por ejemplo,

   correcta [(1,A),(2,B),(3,B),(4,C),(5,A),(6,A),(7,B)] mapa == True
   correcta [(1,A),(2,B),(3,A),(4,C),(5,A),(6,A),(7,B)] mapa == False

1 2	correcta [(1,A),(2,B),(3,B),(4,C),(5,A),(6,A),(7,B)] mapa == True correcta [(1,A),(2,B),(3,A),(4,C),(5,A),(6,A),(7,B)] mapa == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Coloreado_correcto_de_un_mapa where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo')
import Test.Hspec (Spec, hspec, it, shouldBe)

mapa :: Grafo Int Int
mapa = creaGrafo' ND (1,7)
                  [(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),
                   (3,6),(4,5),(4,6),(4,7),(5,7),(6,7)]

data Color = A | B | C | E
  deriving (Eq, Show)

correcta :: [(Int,Color)] -> Grafo Int Int -> Bool
correcta ncs g =
  and [color x /= color y | ((x,y),_) <- aristas g]
  where color x = head [c | (y,c) <- ncs, y == x]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    correcta [(1,A),(2,B),(3,B),(4,C),(5,A),(6,A),(7,B)] mapa `shouldBe` True
  it "e2" $
    correcta [(1,A),(2,B),(3,A),(4,C),(5,A),(6,A),(7,B)] mapa `shouldBe` False

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.0004 seconds
--    2 examples, 0 failures

module Grafo_Coloreado_correcto_de_un_mapa where

import TAD.Grafo (Grafo, Orientacion (ND), aristas, creaGrafo')

import Test.Hspec (Spec, hspec, it, shouldBe)

mapa :: Grafo Int Int

mapa = creaGrafo' ND (1,7)

[(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),

(3,6),(4,5),(4,6),(4,7),(5,7),(6,7)]

data Color = A | B | C | E

deriving (Eq, Show)

correcta :: [(Int,Color)] -> Grafo Int Int -> Bool

correcta ncs g =

and [color x /= color y | ((x,y),_) <- aristas g]

where color x = head [c | (y,c) <- ncs, y == x]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

correcta [(1,A),(2,B),(3,B),(4,C),(5,A),(6,A),(7,B)] mapa `shouldBe` True

it "e2" $

correcta [(1,A),(2,B),(3,A),(4,C),(5,A),(6,A),(7,B)] mapa `shouldBe` False

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.0004 seconds

-- 2 examples, 0 failures

Soluciones en Python

from enum import Enum

from src.TAD.Grafo import Grafo, Orientacion, aristas, creaGrafo_

mapa: Grafo = creaGrafo_(Orientacion.ND,
                         (1,7),
                         [(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),
                          (3,6),(4,5),(4,6),(4,7),(5,7),(6,7)])

Color = Enum('Color', ['A', 'B', 'C', 'E'])

def correcta(ncs: list[tuple[int, Color]], g: Grafo) -> bool:
    def color(x: int) -> Color:
        return [c for (y, c) in ncs if y == x][0]
    return all(color(x) != color(y) for ((x, y), _) in aristas(g))

# Verificación
# ============

def test_correcta() -> None:
    assert correcta([(1,Color.A),
                     (2,Color.B),
                     (3,Color.B),
                     (4,Color.C),
                     (5,Color.A),
                     (6,Color.A),
                     (7,Color.B)],
                    mapa)
    assert not correcta([(1,Color.A),
                         (2,Color.B),
                         (3,Color.A),
                         (4,Color.C),
                         (5,Color.A),
                         (6,Color.A),
                         (7,Color.B)],
                        mapa)
    print("Verificado")

# La verificación es
#    >>> test_correcta()
#    Verificado

from enum import Enum

from src.TAD.Grafo import Grafo, Orientacion, aristas, creaGrafo_

mapa: Grafo = creaGrafo_(Orientacion.ND,

(1,7),

[(1,2),(1,3),(1,4),(2,4),(2,5),(3,4),

(3,6),(4,5),(4,6),(4,7),(5,7),(6,7)])

Color = Enum('Color', ['A', 'B', 'C', 'E'])

def correcta(ncs: list[tuple[int, Color]], g: Grafo) -> bool:

def color(x: int) -> Color:

return [c for (y, c) in ncs if y == x][0]

return all(color(x) != color(y) for ((x, y), _) in aristas(g))

# Verificación

# ============

def test_correcta() -> None:

assert correcta([(1,Color.A),

(2,Color.B),

(3,Color.B),

(4,Color.C),

(5,Color.A),

(6,Color.A),

(7,Color.B)],

mapa)

assert not correcta([(1,Color.A),

(2,Color.B),

(3,Color.A),

(4,Color.C),

(5,Color.A),

(6,Color.A),

(7,Color.B)],

mapa)

print("Verificado")

# La verificación es

# >>> test_correcta()

# Verificado

TAD de los grafos: Grafos conexos

PorJosé A. Alonso 16-junio-202310-junio-2023

Un grafo no dirigido G se dice conexo, si para cualquier par de vértices u y v en G, existe al menos una trayectoria (una sucesión de vértices adyacentes) de u a v.

Usando el tipo abstracto de datos de los grafos, definir la función,

   conexo :: (Ix a, Num p, Eq p) => Grafo a p -> Bool

1	conexo :: (Ix a, Num p, Eq p) => Grafo a p -> Bool

tal que conexo g se verifica si el grafo g es conexo. Por ejemplo,

   conexo (creaGrafo' ND (1,3) [(1,2),(3,2)])        ==  True
   conexo (creaGrafo' ND (1,4) [(1,2),(3,2),(4,1)])  ==  True
   conexo (creaGrafo' ND (1,4) [(1,2),(3,4)])        ==  False

conexo (creaGrafo' ND (1,3) [(1,2),(3,2)]) == True

conexo (creaGrafo' ND (1,4) [(1,2),(3,2),(4,1)]) == True

conexo (creaGrafo' ND (1,4) [(1,2),(3,4)]) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grafos_conexos where

import TAD.Grafo (Grafo, Orientacion (ND), nodos, creaGrafo')
import Data.Ix (Ix)
import Grafo_Recorrido_en_anchura (recorridoEnAnchura)
import Test.Hspec (Spec, hspec, it, shouldBe)

conexo :: (Ix a, Num p, Eq p) => Grafo a p -> Bool
conexo g = length (recorridoEnAnchura i g) == n
  where xs = nodos g
        i  = head xs
        n  = length xs

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    conexo g1 `shouldBe` True
  it "e2" $
    conexo g2 `shouldBe` True
  it "e3" $
    conexo g3 `shouldBe` False
  where
    g1, g2, g3 :: Grafo Int Int
    g1 = creaGrafo' ND (1,3) [(1,2),(3,2)]
    g2 = creaGrafo' ND (1,4) [(1,2),(3,2),(4,1)]
    g3 = creaGrafo' ND (1,4) [(1,2),(3,4)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--
--    Finished in 0.0003 seconds
--    3 examples, 0 failures

module Grafo_Grafos_conexos where

import TAD.Grafo (Grafo, Orientacion (ND), nodos, creaGrafo')

import Data.Ix (Ix)

import Grafo_Recorrido_en_anchura (recorridoEnAnchura)

import Test.Hspec (Spec, hspec, it, shouldBe)

conexo :: (Ix a, Num p, Eq p) => Grafo a p -> Bool

conexo g = length (recorridoEnAnchura i g) == n

where xs = nodos g

i = head xs

n = length xs

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

conexo g1 `shouldBe` True

it "e2" $

conexo g2 `shouldBe` True

it "e3" $

conexo g3 `shouldBe` False

where

g1, g2, g3 :: Grafo Int Int

g1 = creaGrafo' ND (1,3) [(1,2),(3,2)]

g2 = creaGrafo' ND (1,4) [(1,2),(3,2),(4,1)]

g3 = creaGrafo' ND (1,4) [(1,2),(3,4)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- Finished in 0.0003 seconds

-- 3 examples, 0 failures

Soluciones en Python

from src.Grafo_Recorrido_en_anchura import recorridoEnAnchura
from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos


def conexo(g: Grafo) -> bool:
    xs = nodos(g)
    i = xs[0]
    n = len(xs)
    return len(recorridoEnAnchura(i, g)) == n

# Verificación
# ============

def test_conexo() -> None:
    g1 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(3,2)])
    g2 = creaGrafo_(Orientacion.ND, (1,4), [(1,2),(3,2),(4,1)])
    g3 = creaGrafo_(Orientacion.ND, (1,4), [(1,2),(3,4)])
    assert conexo(g1)
    assert conexo(g2)
    assert not conexo(g3)
    print("Verificado")

# La verificación es
#    >>> test_conexo()
#    Verificado

from src.Grafo_Recorrido_en_anchura import recorridoEnAnchura

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos

def conexo(g: Grafo) -> bool:

xs = nodos(g)

i = xs[0]

n = len(xs)

return len(recorridoEnAnchura(i, g)) == n

# Verificación

# ============

def test_conexo() -> None:

g1 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(3,2)])

g2 = creaGrafo_(Orientacion.ND, (1,4), [(1,2),(3,2),(4,1)])

g3 = creaGrafo_(Orientacion.ND, (1,4), [(1,2),(3,4)])

assert conexo(g1)

assert conexo(g2)

assert not conexo(g3)

print("Verificado")

# La verificación es

# >>> test_conexo()

# Verificado

TAD de los grafos: Recorrido en anchura

PorJosé A. Alonso 15-junio-20237-junio-2023

Usando el tipo abstracto de datos de los grafos, definir la función,

   recorridoEnAnchura :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

1	recorridoEnAnchura :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

tal que recorridoEnAnchura i g es el recorrido en anchura del grafo g desde el vértice i. Por ejemplo, en el grafo

   +---> 2 <---+
   |           |
   |           |
   1 --> 3 --> 6 --> 5
   |                 |
   |                 |
   +---> 4 <---------+

+---> 2 <---+

| |

1 --> 3 --> 6 --> 5

| |

+---> 4 <---------+

definido por

   grafo1 :: Grafo Int Int
   grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

1 2	grafo1 :: Grafo Int Int grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

entonces

   recorridoEnAnchura 1 grafo1  ==  [1,2,3,4,6,5]

1	recorridoEnAnchura 1 grafo1 == [1,2,3,4,6,5]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Recorrido_en_anchura where
import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes,
                  creaGrafo')
import Data.Ix (Ix)
import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int
grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

recorridoEnAnchura :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]
recorridoEnAnchura i g = reverse (ra [i] [])
  where
    ra [] vis    = vis
    ra (c:cs) vis
        | c `elem` vis = ra cs vis
        | otherwise    = ra (cs ++ adyacentes g c) (c:vis)

-- Traza del cálculo de (recorridoEnAnchura1 1 grafo1)
--    recorridoEnAnchura1 1 grafo1
--    = ra [1]     []
--    = ra [2,3,4] [1]
--    = ra [3,4]   [2,1]
--    = ra [4,6]   [3,2,1]
--    = ra [6]     [4,3,2,1]
--    = ra [2,5]   [6,4,3,2,1]
--    = ra [5]     [6,4,3,2,1]
--    = ra [4]     [5,6,4,3,2,1]
--    = ra []      [5,6,4,3,2,1]
--    = [1,2,3,4,6,5]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    recorridoEnAnchura 1 grafo1 `shouldBe` [1,2,3,4,6,5]
  it "e2" $
    recorridoEnAnchura 1 grafo2 `shouldBe` [1,2,3,4,6,5]
  where
    grafo2 :: Grafo Int Int
    grafo2 = creaGrafo' ND (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.0010 seconds
--    2 examples, 0 failures

module Grafo_Recorrido_en_anchura where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes,

creaGrafo')

import Data.Ix (Ix)

import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

recorridoEnAnchura :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

recorridoEnAnchura i g = reverse (ra [i] [])

where

ra [] vis = vis

ra (c:cs) vis

| c `elem` vis = ra cs vis

| otherwise = ra (cs ++ adyacentes g c) (c:vis)

-- Traza del cálculo de (recorridoEnAnchura1 1 grafo1)

-- recorridoEnAnchura1 1 grafo1

-- = ra [1] []

-- = ra [2,3,4] [1]

-- = ra [3,4] [2,1]

-- = ra [4,6] [3,2,1]

-- = ra [6] [4,3,2,1]

-- = ra [2,5] [6,4,3,2,1]

-- = ra [5] [6,4,3,2,1]

-- = ra [4] [5,6,4,3,2,1]

-- = ra [] [5,6,4,3,2,1]

-- = [1,2,3,4,6,5]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

recorridoEnAnchura 1 grafo1 `shouldBe` [1,2,3,4,6,5]

it "e2" $

recorridoEnAnchura 1 grafo2 `shouldBe` [1,2,3,4,6,5]

where

grafo2 :: Grafo Int Int

grafo2 = creaGrafo' ND (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.0010 seconds

-- 2 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

grafo1: Grafo = creaGrafo_(Orientacion.D,
                           (1,6),
                           [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

def recorridoEnAnchura(i: Vertice, g: Grafo) -> list[Vertice]:
    def ra(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:
        if not cs:
            return vis
        d, *ds = cs
        if d in vis:
            return ra(ds, vis)
        return ra(ds + adyacentes(g, d), [d] + vis)
    return list(reversed(ra([i], [])))

# Traza del cálculo de recorridoEnAnchura(1, grafo1)
#    recorridoEnAnchura(1, grafo1
#    = ra([1],     [])
#    = ra([2,3,4], [1])
#    = ra([3,4],   [2,1])
#    = ra([4,6],   [3,2,1])
#    = ra([6],     [4,3,2,1])
#    = ra([2,5],   [6,4,3,2,1])
#    = ra([5],     [6,4,3,2,1])
#    = ra([4],     [5,6,4,3,2,1])
#    = ra([],      [5,6,4,3,2,1])
#    = [1,2,3,4,6,5]

# Verificación
# ============

def test_recorridoEnAnchura() -> None:
    grafo2 = creaGrafo_(Orientacion.ND,
                        (1,6),
                        [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])
    assert recorridoEnAnchura(1, grafo1) == [1,2,3,4,6,5]
    assert recorridoEnAnchura(1, grafo2) == [1,2,3,4,6,5]
    print("Verificado")

# La verificación es
#    >>> test_recorridoEnAnchura()
#    Verificado

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

grafo1: Grafo = creaGrafo_(Orientacion.D,

(1,6),

[(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

def recorridoEnAnchura(i: Vertice, g: Grafo) -> list[Vertice]:

def ra(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:

if not cs:

return vis

d, *ds = cs

if d in vis:

return ra(ds, vis)

return ra(ds + adyacentes(g, d), [d] + vis)

return list(reversed(ra([i], [])))

# Traza del cálculo de recorridoEnAnchura(1, grafo1)

# recorridoEnAnchura(1, grafo1

# = ra([1], [])

# = ra([2,3,4], [1])

# = ra([3,4], [2,1])

# = ra([4,6], [3,2,1])

# = ra([6], [4,3,2,1])

# = ra([2,5], [6,4,3,2,1])

# = ra([5], [6,4,3,2,1])

# = ra([4], [5,6,4,3,2,1])

# = ra([], [5,6,4,3,2,1])

# = [1,2,3,4,6,5]

# Verificación

# ============

def test_recorridoEnAnchura() -> None:

grafo2 = creaGrafo_(Orientacion.ND,

(1,6),

[(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

assert recorridoEnAnchura(1, grafo1) == [1,2,3,4,6,5]

assert recorridoEnAnchura(1, grafo2) == [1,2,3,4,6,5]

print("Verificado")

# La verificación es

# >>> test_recorridoEnAnchura()

# Verificado

TAD de los grafos: Recorrido en profundidad

PorJosé A. Alonso 14-junio-20235-junio-2023

Usando el tipo abstracto de datos de los grafos, definir la función,

   recorridoEnProfundidad :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

1	recorridoEnProfundidad :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

tal que recorridoEnProfundidad i g es el recorrido en profundidad del grafo g desde el vértice i. Por ejemplo, en el grafo

   +---> 2 <---+
   |           |
   |           |
   1 --> 3 --> 6 --> 5
   |                 |
   |                 |
   +---> 4 <---------+

+---> 2 <---+

| |

1 --> 3 --> 6 --> 5

| |

+---> 4 <---------+

definido por

   grafo1 :: Grafo Int Int
   grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

1 2	grafo1 :: Grafo Int Int grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

entonces

   recorridoEnProfundidad 1 grafo1  ==  [1,2,3,6,5,4]

1	recorridoEnProfundidad 1 grafo1 == [1,2,3,6,5,4]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Recorrido_en_profundidad where
import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes,
                  creaGrafo')
import Data.Ix (Ix)
import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int
grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- 1ª solución
-- ===========

recorridoEnProfundidad1 :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]
recorridoEnProfundidad1 i g = rp [i] []
  where
    rp [] vis    = vis
    rp (c:cs) vis
        | c `elem` vis = rp cs vis
        | otherwise    = rp (adyacentes g c ++ cs) (vis ++ [c])

-- Traza del cálculo de (recorridoEnProfundidad1 1 grafo1)
--    recorridoEnProfundidad1 1 grafo1
--    = rp [1]     []
--    = rp [2,3,4] [1]
--    = rp [3,4]   [1,2]
--    = rp [6,4]   [1,2,3]
--    = rp [2,5,4] [1,2,3,6]
--    = rp [5,4]   [1,2,3,6]
--    = rp [4,4]   [1,2,3,6,5]
--    = rp [4]     [1,2,3,6,5,4]
--    = rp []      [1,2,3,6,5,4]
--    = [1,2,3,6,5,4]

-- 2ª solución
-- ===========

recorridoEnProfundidad :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]
recorridoEnProfundidad i g = reverse (rp [i] [])
  where
    rp [] vis     = vis
    rp (c:cs) vis
        | c `elem` vis = rp cs vis
        | otherwise    = rp (adyacentes g c ++ cs) (c:vis)

-- Traza del cálculo de (recorridoEnProfundidad 1 grafo1)
--    RecorridoEnProfundidad 1 grafo1
--    = reverse (rp [1]     [])
--    = reverse (rp [2,3,4] [1])
--    = reverse (rp [3,4]   [2,1])
--    = reverse (rp [6,4]   [3,2,1])
--    = reverse (rp [2,5,4] [6,3,2,1])
--    = reverse (rp [5,4]   [6,3,2,1])
--    = reverse (rp [4,4]   [5,6,3,2,1])
--    = reverse (rp [4]     [4,5,6,3,2,1])
--    = reverse (rp []      [4,5,6,3,2,1])
--    = reverse [4,5,6,3,2,1]
--    = [1,2,3,6,5,4]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    recorridoEnProfundidad1 1 grafo1 `shouldBe` [1,2,3,6,5,4]
  it "e2" $
    recorridoEnProfundidad 1 grafo1 `shouldBe` [1,2,3,6,5,4]
  it "e3" $
    recorridoEnProfundidad1 1 grafo2 `shouldBe` [1,2,6,3,5,4]
  it "e4" $
    recorridoEnProfundidad 1 grafo2 `shouldBe` [1,2,6,3,5,4]
  where
    grafo2 :: Grafo Int Int
    grafo2 = creaGrafo' ND (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--
--    Finished in 0.0022 seconds
--    4 examples, 0 failures

module Grafo_Recorrido_en_profundidad where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes,

creaGrafo')

import Data.Ix (Ix)

import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- 1ª solución

-- ===========

recorridoEnProfundidad1 :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

recorridoEnProfundidad1 i g = rp [i] []

where

rp [] vis = vis

rp (c:cs) vis

| c `elem` vis = rp cs vis

| otherwise = rp (adyacentes g c ++ cs) (vis ++ [c])

-- Traza del cálculo de (recorridoEnProfundidad1 1 grafo1)

-- recorridoEnProfundidad1 1 grafo1

-- = rp [1] []

-- = rp [2,3,4] [1]

-- = rp [3,4] [1,2]

-- = rp [6,4] [1,2,3]

-- = rp [2,5,4] [1,2,3,6]

-- = rp [5,4] [1,2,3,6]

-- = rp [4,4] [1,2,3,6,5]

-- = rp [4] [1,2,3,6,5,4]

-- = rp [] [1,2,3,6,5,4]

-- = [1,2,3,6,5,4]

-- 2ª solución

-- ===========

recorridoEnProfundidad :: (Num p, Eq p, Ix v) => v -> Grafo v p -> [v]

recorridoEnProfundidad i g = reverse (rp [i] [])

where

rp [] vis = vis

rp (c:cs) vis

| c `elem` vis = rp cs vis

| otherwise = rp (adyacentes g c ++ cs) (c:vis)

-- Traza del cálculo de (recorridoEnProfundidad 1 grafo1)

-- RecorridoEnProfundidad 1 grafo1

-- = reverse (rp [1] [])

-- = reverse (rp [2,3,4] [1])

-- = reverse (rp [3,4] [2,1])

-- = reverse (rp [6,4] [3,2,1])

-- = reverse (rp [2,5,4] [6,3,2,1])

-- = reverse (rp [5,4] [6,3,2,1])

-- = reverse (rp [4,4] [5,6,3,2,1])

-- = reverse (rp [4] [4,5,6,3,2,1])

-- = reverse (rp [] [4,5,6,3,2,1])

-- = reverse [4,5,6,3,2,1]

-- = [1,2,3,6,5,4]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

recorridoEnProfundidad1 1 grafo1 `shouldBe` [1,2,3,6,5,4]

it "e2" $

recorridoEnProfundidad 1 grafo1 `shouldBe` [1,2,3,6,5,4]

it "e3" $

recorridoEnProfundidad1 1 grafo2 `shouldBe` [1,2,6,3,5,4]

it "e4" $

recorridoEnProfundidad 1 grafo2 `shouldBe` [1,2,6,3,5,4]

where

grafo2 :: Grafo Int Int

grafo2 = creaGrafo' ND (1,6) [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- Finished in 0.0022 seconds

-- 4 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

grafo1: Grafo = creaGrafo_(Orientacion.D,
                           (1,6),
                           [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

# 1ª solución
# ===========

def recorridoEnProfundidad1(i: Vertice, g: Grafo) -> list[Vertice]:
    def rp(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:
        if not cs:
            return vis
        d, *ds = cs
        if d in vis:
            return rp(ds, vis)
        return rp(adyacentes(g, d) + ds, vis + [d])
    return rp([i], [])

# Traza del cálculo de recorridoEnProfundidad1(1, grafo1)
#    recorridoEnProfundidad1(1, grafo1)
#    = rp([1],     [])
#    = rp([2,3,4], [1])
#    = rp([3,4],   [1,2])
#    = rp([6,4],   [1,2,3])
#    = rp([2,5,4], [1,2,3,6])
#    = rp([5,4],   [1,2,3,6])
#    = rp([4,4],   [1,2,3,6,5])
#    = rp([4],     [1,2,3,6,5,4])
#    = rp([],      [1,2,3,6,5,4])
#    = [1,2,3,6,5,4]

# 2ª solución
# ===========

def recorridoEnProfundidad(i: Vertice, g: Grafo) -> list[Vertice]:
    def rp(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:
        if not cs:
            return vis
        d, *ds = cs
        if d in vis:
            return rp(ds, vis)
        return rp(adyacentes(g, d) + ds, [d] + vis)
    return list(reversed(rp([i], [])))

# Traza del cálculo de (recorridoEnProfundidad(1, grafo1)
#    recorridoEnProfundidad(1, grafo1)
#    = reverse(rp([1],     []))
#    = reverse(rp([2,3,4], [1]))
#    = reverse(rp([3,4],   [2,1]))
#    = reverse(rp([6,4],   [3,2,1]))
#    = reverse(rp([2,5,4], [6,3,2,1]))
#    = reverse(rp([5,4],   [6,3,2,1]))
#    = reverse(rp([4,4],   [5,6,3,2,1]))
#    = reverse(rp([4],     [4,5,6,3,2,1]))
#    = reverse(rp([],      [4,5,6,3,2,1]))
#    = reverse([4,5,6,3,2,1])
#    = [1,2,3,6,5,4]

# Verificación
# ============

def test_recorridoEnProfundidad() -> None:
    grafo2 = creaGrafo_(Orientacion.ND,
                        (1,6),
                        [(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])
    assert recorridoEnProfundidad1(1, grafo1) == [1,2,3,6,5,4]
    assert recorridoEnProfundidad1(1, grafo2) == [1,2,6,3,5,4]
    assert recorridoEnProfundidad(1, grafo1) == [1,2,3,6,5,4]
    assert recorridoEnProfundidad(1, grafo2) == [1,2,6,3,5,4]
    print("Verificado")

# La verificación es
#    >>> test_recorridoEnProfundidad()
#    Verificado

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

grafo1: Grafo = creaGrafo_(Orientacion.D,

(1,6),

[(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

# 1ª solución

# ===========

def recorridoEnProfundidad1(i: Vertice, g: Grafo) -> list[Vertice]:

def rp(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:

if not cs:

return vis

d, *ds = cs

if d in vis:

return rp(ds, vis)

return rp(adyacentes(g, d) + ds, vis + [d])

return rp([i], [])

# Traza del cálculo de recorridoEnProfundidad1(1, grafo1)

# recorridoEnProfundidad1(1, grafo1)

# = rp([1], [])

# = rp([2,3,4], [1])

# = rp([3,4], [1,2])

# = rp([6,4], [1,2,3])

# = rp([2,5,4], [1,2,3,6])

# = rp([5,4], [1,2,3,6])

# = rp([4,4], [1,2,3,6,5])

# = rp([4], [1,2,3,6,5,4])

# = rp([], [1,2,3,6,5,4])

# = [1,2,3,6,5,4]

# 2ª solución

# ===========

def recorridoEnProfundidad(i: Vertice, g: Grafo) -> list[Vertice]:

def rp(cs: list[Vertice], vis: list[Vertice]) -> list[Vertice]:

if not cs:

return vis

d, *ds = cs

if d in vis:

return rp(ds, vis)

return rp(adyacentes(g, d) + ds, [d] + vis)

return list(reversed(rp([i], [])))

# Traza del cálculo de (recorridoEnProfundidad(1, grafo1)

# recorridoEnProfundidad(1, grafo1)

# = reverse(rp([1], []))

# = reverse(rp([2,3,4], [1]))

# = reverse(rp([3,4], [2,1]))

# = reverse(rp([6,4], [3,2,1]))

# = reverse(rp([2,5,4], [6,3,2,1]))

# = reverse(rp([5,4], [6,3,2,1]))

# = reverse(rp([4,4], [5,6,3,2,1]))

# = reverse(rp([4], [4,5,6,3,2,1]))

# = reverse(rp([], [4,5,6,3,2,1]))

# = reverse([4,5,6,3,2,1])

# = [1,2,3,6,5,4]

# Verificación

# ============

def test_recorridoEnProfundidad() -> None:

grafo2 = creaGrafo_(Orientacion.ND,

(1,6),

[(1,2),(1,3),(1,4),(3,6),(5,4),(6,2),(6,5)])

assert recorridoEnProfundidad1(1, grafo1) == [1,2,3,6,5,4]

assert recorridoEnProfundidad1(1, grafo2) == [1,2,6,3,5,4]

assert recorridoEnProfundidad(1, grafo1) == [1,2,3,6,5,4]

assert recorridoEnProfundidad(1, grafo2) == [1,2,6,3,5,4]

print("Verificado")

# La verificación es

# >>> test_recorridoEnProfundidad()

# Verificado

TAD de los grafos: Anchura de un grafo

PorJosé A. Alonso 13-junio-20234-junio-2023

En un grafo, la anchura de un nodo es el máximo de los absolutos de la diferencia entre el valor del nodo y los de sus adyacentes; y la anchura del grafo es la máxima anchura de sus nodos. Por ejemplo, en el grafo

   grafo1 :: Grafo Int Int
   grafo1 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),
                                (2,4),(2,5),
                                (3,4),(3,5),
                                (4,5)]

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),

(2,4),(2,5),

(3,4),(3,5),

(4,5)]

su anchura es 4 y el nodo de máxima anchura es el 5.

Usando el tipo abstracto de datos de los grafos, definir la función,

   anchura :: Grafo Int Int -> Int

1	anchura :: Grafo Int Int -> Int

tal que (anchuraG g) es la anchura del grafo g. Por ejemplo,

   anchura grafo1  ==  4

1	anchura grafo1 == 4

Comprobar experimentalmente que la anchura del grafo ciclo de orden n es n-1.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Anchura_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, aristas,
                  creaGrafo', nodos)
import Grafo_Grafos_ciclos (grafoCiclo)
import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int
grafo1 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),
                             (2,4),(2,5),
                             (3,4),(3,5),
                             (4,5)]

-- 1ª solución
-- ===========

anchura :: Grafo Int Int -> Int
anchura g = maximum [anchuraN g x | x <- nodos g]

-- (anchuraN g x) es la anchura del nodo x en el grafo g. Por ejemplo,
--    anchuraN g 1  ==  4
--    anchuraN g 2  ==  3
--    anchuraN g 4  ==  2
--    anchuraN g 5  ==  4
anchuraN :: Grafo Int Int -> Int -> Int
anchuraN g x = maximum (0 : [abs (x-v) | v <- adyacentes g x])

-- 2ª solución
-- ===========

anchura2 :: Grafo Int Int -> Int
anchura2 g = maximum [abs (x-y) | ((x,y),_) <- aristas g]

-- La conjetura
conjetura :: Int -> Bool
conjetura n = anchura (grafoCiclo n) == n-1

-- La comprobación es
--    λ> and [conjetura n | n <- [2..10]]
--    True

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    anchura grafo1 `shouldBe` 4
  it "e2" $
    anchura g2 `shouldBe` 2
  where
    g2 :: Grafo Int Int
    g2 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--
--    Finished in 0.0004 seconds
--    2 examples, 0 failures

module Grafo_Anchura_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, aristas,

creaGrafo', nodos)

import Grafo_Grafos_ciclos (grafoCiclo)

import Test.Hspec (Spec, hspec, it, shouldBe)

grafo1 :: Grafo Int Int

grafo1 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),

(2,4),(2,5),

(3,4),(3,5),

(4,5)]

-- 1ª solución

-- ===========

anchura :: Grafo Int Int -> Int

anchura g = maximum [anchuraN g x | x <- nodos g]

-- (anchuraN g x) es la anchura del nodo x en el grafo g. Por ejemplo,

-- anchuraN g 1 == 4

-- anchuraN g 2 == 3

-- anchuraN g 4 == 2

-- anchuraN g 5 == 4

anchuraN :: Grafo Int Int -> Int -> Int

anchuraN g x = maximum (0 : [abs (x-v) | v <- adyacentes g x])

-- 2ª solución

-- ===========

anchura2 :: Grafo Int Int -> Int

anchura2 g = maximum [abs (x-y) | ((x,y),_) <- aristas g]

-- La conjetura

conjetura :: Int -> Bool

conjetura n = anchura (grafoCiclo n) == n-1

-- La comprobación es

-- λ> and [conjetura n | n <- [2..10]]

-- True

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

anchura grafo1 `shouldBe` 4

it "e2" $

anchura g2 `shouldBe` 2

where

g2 :: Grafo Int Int

g2 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- Finished in 0.0004 seconds

-- 2 examples, 0 failures

Soluciones en Python

from src.Grafo_Grafos_ciclos import grafoCiclo
from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, aristas,
                           creaGrafo_, nodos)

grafo1: Grafo = creaGrafo_(Orientacion.D, (1,5), [(1,2),(1,3),(1,5),
                                                  (2,4),(2,5),
                                                  (3,4),(3,5),
                                                  (4,5)])

# 1ª solución
# ===========

def anchura(g: Grafo) -> int:
    return max(anchuraN(g, x) for x in nodos(g))

# (anchuraN g x) es la anchura del nodo x en el grafo g. Por ejemplo,
#    anchuraN g 1  ==  4
#    anchuraN g 2  ==  3
#    anchuraN g 4  ==  2
#    anchuraN g 5  ==  4
def anchuraN(g: Grafo, x: Vertice) -> int:
    return max([0] + [abs (x - v) for v in adyacentes(g, x)])

# 2ª solución
# ===========

def anchura2(g: Grafo) -> int:
    return max(abs (x-y) for ((x,y),_) in aristas(g))

# La conjetura
def conjetura(n: int) -> bool:
    return anchura(grafoCiclo(n)) == n - 1

# La comprobación es
#    >>> all(conjetura(n) for n in range(2, 11))
#    True

# Verificación
# ============

def test_anchura() -> None:
    g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(1,3),(2,3),(3,3)])
    assert anchura(grafo1) == 4
    assert anchura(g2) == 2
    print("Verificado")

# La verificación es
#    >>> test_anchura()
#    Verificado

from src.Grafo_Grafos_ciclos import grafoCiclo

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, aristas,

creaGrafo_, nodos)

grafo1: Grafo = creaGrafo_(Orientacion.D, (1,5), [(1,2),(1,3),(1,5),

(2,4),(2,5),

(3,4),(3,5),

(4,5)])

# 1ª solución

# ===========

def anchura(g: Grafo) -> int:

return max(anchuraN(g, x) for x in nodos(g))

# (anchuraN g x) es la anchura del nodo x en el grafo g. Por ejemplo,

# anchuraN g 1 == 4

# anchuraN g 2 == 3

# anchuraN g 4 == 2

# anchuraN g 5 == 4

def anchuraN(g: Grafo, x: Vertice) -> int:

return max([0] + [abs (x - v) for v in adyacentes(g, x)])

# 2ª solución

# ===========

def anchura2(g: Grafo) -> int:

return max(abs (x-y) for ((x,y),_) in aristas(g))

# La conjetura

def conjetura(n: int) -> bool:

return anchura(grafoCiclo(n)) == n - 1

# La comprobación es

# >>> all(conjetura(n) for n in range(2, 11))

# True

# Verificación

# ============

def test_anchura() -> None:

g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(1,3),(2,3),(3,3)])

assert anchura(grafo1) == 4

assert anchura(g2) == 2

print("Verificado")

# La verificación es

# >>> test_anchura()

# Verificado

TAD de los grafos: Recorridos en un grafo completo

PorJosé A. Alonso 12-junio-20231-junio-2023

Definir la función

   recorridos :: [a] -> [[a]]

1	recorridos :: [a] -> [[a]]

tal que recorridos xs es la lista de todos los posibles por el grafo cuyo conjunto de vértices es xs y cada vértice se encuentra conectado con todos los otros y los recorridos pasan por todos los vértices una vez y terminan en el vértice inicial. Por ejemplo,

   λ> recorridos [2,5,3]
   [[2,5,3,2],[5,2,3,5],[3,5,2,3],[5,3,2,5],[3,2,5,3],[2,3,5,2]]

1 2	λ> recorridos [2,5,3] [[2,5,3,2],[5,2,3,5],[3,5,2,3],[5,3,2,5],[3,2,5,3],[2,3,5,2]]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Recorridos_en_un_grafo_completo where

import Data.List (permutations)
import Test.Hspec (Spec, hspec, it, shouldBe)

recorridos :: [a] -> [[a]]
recorridos xs = [(y:ys) ++ [y] | y:ys <- permutations xs]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    recorridos [2 :: Int,5,3] `shouldBe`
    [[2,5,3,2],[5,2,3,5],[3,5,2,3],[5,3,2,5],[3,2,5,3],[2,3,5,2]]

-- La verificación es
--    λ> verifica
--
--    e1
--
--    Finished in 0.0007 seconds
--    1 example, 0 failures

module Grafo_Recorridos_en_un_grafo_completo where

import Data.List (permutations)

import Test.Hspec (Spec, hspec, it, shouldBe)

recorridos :: [a] -> [[a]]

recorridos xs = [(y:ys) ++ [y] | y:ys <- permutations xs]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

recorridos [2 :: Int,5,3] `shouldBe`

[[2,5,3,2],[5,2,3,5],[3,5,2,3],[5,3,2,5],[3,2,5,3],[2,3,5,2]]

-- La verificación es

-- λ> verifica

-- e1

-- Finished in 0.0007 seconds

-- 1 example, 0 failures

Soluciones en Python

from itertools import permutations
from typing import TypeVar

A = TypeVar('A')

def recorridos(xs: list[A]) -> list[list[A]]:
    return [(list(y) + [y[0]]) for y in permutations(xs)]

# Verificación
# ============

def test_recorridos() -> None:
    assert recorridos([2, 5, 3]) \
        == [[2, 5, 3, 2], [2, 3, 5, 2], [5, 2, 3, 5], [5, 3, 2, 5],
            [3, 2, 5, 3], [3, 5, 2, 3]]
    print("Verificado")

# La verificación es
#    >>> test_recorridos()
#    Verificado

from itertools import permutations

from typing import TypeVar

A = TypeVar('A')

def recorridos(xs: list[A]) -> list[list[A]]:

return [(list(y) + [y[0]]) for y in permutations(xs)]

# Verificación

# ============

def test_recorridos() -> None:

assert recorridos([2, 5, 3]) \

== [[2, 5, 3, 2], [2, 3, 5, 2], [5, 2, 3, 5], [5, 3, 2, 5],

[3, 2, 5, 3], [3, 5, 2, 3]]

print("Verificado")

# La verificación es

# >>> test_recorridos()

# Verificado

TAD de los grafos: Grafos k-regulares

PorJosé A. Alonso 9-junio-20233-junio-2023

Un grafo k-regular es un grafo con todos sus vértices son de grado k.

Usando el tipo abstracto de datos de los grafos, definir la función,

   regularidad :: (Ix v,Num p) => Grafo v p -> Maybe Int

1	regularidad :: (Ix v,Num p) => Grafo v p -> Maybe Int

tal que (regularidad g) es la regularidad de g. Por ejemplo,

   regularidad (creaGrafo' ND (1,2) [(1,2),(2,3)]) == Just 1
   regularidad (creaGrafo' D (1,2) [(1,2),(2,3)])  == Nothing
   regularidad (completo 4)                        == Just 3
   regularidad (completo 5)                        == Just 4
   regularidad (grafoCiclo 4)                      == Just 2
   regularidad (grafoCiclo 5)                      == Just 2

regularidad (creaGrafo' ND (1,2) [(1,2),(2,3)]) == Just 1

regularidad (creaGrafo' D (1,2) [(1,2),(2,3)]) == Nothing

regularidad (completo 4) == Just 3

regularidad (completo 5) == Just 4

regularidad (grafoCiclo 4) == Just 2

regularidad (grafoCiclo 5) == Just 2

Comprobar que el grafo completo de orden n es (n-1)-regular (para n de 1 a 20) y el grafo ciclo de orden n es 2-regular (para n de 3 a 20).

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grafos_k_regulares where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')
import Data.Ix (Ix)
import Grafo_Grado_de_un_vertice (grado)
import Grafo_Grafos_regulares (regular)
import Grafo_Grafos_completos (completo)
import Grafo_Grafos_ciclos (grafoCiclo)
import Test.Hspec (Spec, hspec, it, shouldBe)

regularidad :: (Ix v,Num p) => Grafo v p -> Maybe Int
regularidad g
  | regular g = Just (grado g (head (nodos g)))
  | otherwise = Nothing

-- La propiedad de k-regularidad de los grafos completos es
prop_completoRegular :: Int -> Bool
prop_completoRegular n =
  regularidad (completo n) == Just (n-1)

-- La comprobación es
--    λ> and [prop_completoRegular n | n <- [1..20]]
--    True

-- La propiedad de k-regularidad de los grafos ciclos es
prop_cicloRegular :: Int -> Bool
prop_cicloRegular n =
  regularidad (grafoCiclo n) == Just 2

-- La comprobación es
--    λ> and [prop_cicloRegular n | n <- [3..20]]
--    True

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    regularidad g1             `shouldBe` Just 1
  it "e2" $
    regularidad g2             `shouldBe` Nothing
  it "e3" $
    regularidad (completo 4)   `shouldBe` Just 3
  it "e4" $
    regularidad (completo 5)   `shouldBe` Just 4
  it "e5" $
    regularidad (grafoCiclo 4) `shouldBe` Just 2
  it "e6" $
    regularidad (grafoCiclo 5) `shouldBe` Just 2
  where
    g1, g2 :: Grafo Int Int
    g1 = creaGrafo' ND (1,2) [(1,2),(2,3)]
    g2 = creaGrafo' D (1,2) [(1,2),(2,3)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--    e5
--    e6
--
--    Finished in 0.0027 seconds
--    6 examples, 0 failures

module Grafo_Grafos_k_regulares where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')

import Data.Ix (Ix)

import Grafo_Grado_de_un_vertice (grado)

import Grafo_Grafos_regulares (regular)

import Grafo_Grafos_completos (completo)

import Grafo_Grafos_ciclos (grafoCiclo)

import Test.Hspec (Spec, hspec, it, shouldBe)

regularidad :: (Ix v,Num p) => Grafo v p -> Maybe Int

regularidad g

| regular g = Just (grado g (head (nodos g)))

| otherwise = Nothing

-- La propiedad de k-regularidad de los grafos completos es

prop_completoRegular :: Int -> Bool

prop_completoRegular n =

regularidad (completo n) == Just (n-1)

-- La comprobación es

-- λ> and [prop_completoRegular n | n <- [1..20]]

-- True

-- La propiedad de k-regularidad de los grafos ciclos es

prop_cicloRegular :: Int -> Bool

prop_cicloRegular n =

regularidad (grafoCiclo n) == Just 2

-- La comprobación es

-- λ> and [prop_cicloRegular n | n <- [3..20]]

-- True

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

regularidad g1 `shouldBe` Just 1

it "e2" $

regularidad g2 `shouldBe` Nothing

it "e3" $

regularidad (completo 4) `shouldBe` Just 3

it "e4" $

regularidad (completo 5) `shouldBe` Just 4

it "e5" $

regularidad (grafoCiclo 4) `shouldBe` Just 2

it "e6" $

regularidad (grafoCiclo 5) `shouldBe` Just 2

where

g1, g2 :: Grafo Int Int

g1 = creaGrafo' ND (1,2) [(1,2),(2,3)]

g2 = creaGrafo' D (1,2) [(1,2),(2,3)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- Finished in 0.0027 seconds

-- 6 examples, 0 failures

Soluciones en Python

from typing import Optional

from src.Grafo_Grado_de_un_vertice import grado
from src.Grafo_Grafos_ciclos import grafoCiclo
from src.Grafo_Grafos_completos import completo
from src.Grafo_Grafos_regulares import regular
from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos


def regularidad(g: Grafo) -> Optional[int]:
    if regular(g):
        return grado(g, nodos(g)[0])
    return None

# La propiedad de k-regularidad de los grafos completos es
def prop_completoRegular(n: int) -> bool:
    return regularidad(completo(n)) == n - 1

# La comprobación es
#    >>> all(prop_completoRegular(n) for n in range(1, 21))
#    True

# La propiedad de k-regularidad de los grafos ciclos es
def prop_cicloRegular(n: int) -> bool:
    return regularidad(grafoCiclo(n)) == 2

# La comprobación es
#    >>> all(prop_cicloRegular(n) for n in range(3, 21))
#    True

# Verificación
# ============

def test_k_regularidad() -> None:
    g1 = creaGrafo_(Orientacion.ND, (1,2), [(1,2),(2,3)])
    g2 = creaGrafo_(Orientacion.D, (1,2), [(1,2),(2,3)])
    assert regularidad(g1) == 1
    assert regularidad(g2) is None
    assert regularidad(completo(4)) == 3
    assert regularidad(completo(5)) == 4
    assert regularidad(grafoCiclo(4)) == 2
    assert regularidad(grafoCiclo(5)) == 2
    print("Verificado")

# La verificación es
#    >>> test_k_regularidad()
#    Verificado

from typing import Optional

from src.Grafo_Grado_de_un_vertice import grado

from src.Grafo_Grafos_ciclos import grafoCiclo

from src.Grafo_Grafos_completos import completo

from src.Grafo_Grafos_regulares import regular

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos

def regularidad(g: Grafo) -> Optional[int]:

if regular(g):

return grado(g, nodos(g)[0])

return None

# La propiedad de k-regularidad de los grafos completos es

def prop_completoRegular(n: int) -> bool:

return regularidad(completo(n)) == n - 1

# La comprobación es

# >>> all(prop_completoRegular(n) for n in range(1, 21))

# True

# La propiedad de k-regularidad de los grafos ciclos es

def prop_cicloRegular(n: int) -> bool:

return regularidad(grafoCiclo(n)) == 2

# La comprobación es

# >>> all(prop_cicloRegular(n) for n in range(3, 21))

# True

# Verificación

# ============

def test_k_regularidad() -> None:

g1 = creaGrafo_(Orientacion.ND, (1,2), [(1,2),(2,3)])

g2 = creaGrafo_(Orientacion.D, (1,2), [(1,2),(2,3)])

assert regularidad(g1) == 1

assert regularidad(g2) is None

assert regularidad(completo(4)) == 3

assert regularidad(completo(5)) == 4

assert regularidad(grafoCiclo(4)) == 2

assert regularidad(grafoCiclo(5)) == 2

print("Verificado")

# La verificación es

# >>> test_k_regularidad()

# Verificado

TAD de los grafos: Grafos regulares

PorJosé A. Alonso 8-junio-20233-junio-2023

Un grafo regular es un grafo en el que todos sus vértices tienen el mismo grado.

Usando el tipo abstracto de datos de los grafos, definir la función,

   regular :: (Ix v,Num p) => Grafo v p -> Bool

1	regular :: (Ix v,Num p) => Grafo v p -> Bool

tal que (regular g) se verifica si el grafo g es regular. Por ejemplo,

   λ> regular (creaGrafo' D (1,3) [(1,2),(2,3),(3,1)])
   True
   λ> regular (creaGrafo' ND (1,3) [(1,2),(2,3)])
   False
   λ> regular (completo 4)
   True

λ> regular (creaGrafo' D (1,3) [(1,2),(2,3),(3,1)])

True

λ> regular (creaGrafo' ND (1,3) [(1,2),(2,3)])

False

λ> regular (completo 4)

True

Comprobar que los grafos completos son regulares.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grafos_regulares where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')
import Data.Ix (Ix)
import Grafo_Grado_de_un_vertice (grado)
import Grafo_Grafos_completos (completo)
import Test.Hspec (Spec, hspec, it, shouldBe)

regular :: (Ix v,Num p) => Grafo v p -> Bool
regular g = and [grado g v == k | v <- vs]
  where vs = nodos g
        k  = grado g (head vs)

-- La propiedad de la regularidad de todos los grafos completos de orden
-- entre m y n es
prop_CompletoRegular :: Int -> Int -> Bool
prop_CompletoRegular m n =
  and [regular (completo x) | x <- [m..n]]

-- La comprobación es
--    λ> prop_CompletoRegular 1 30
--    True

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    regular g1 `shouldBe` True
  it "e2" $
    regular g2 `shouldBe` False
  it "e3" $
    regular (completo 4) `shouldBe` True
  where
    g1, g2 :: Grafo Int Int
    g1 = creaGrafo' D (1,3) [(1,2),(2,3),(3,1)]
    g2 = creaGrafo' ND (1,3) [(1,2),(2,3)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--
--    Finished in 0.0006 seconds
--    3 examples, 0 failures

module Grafo_Grafos_regulares where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')

import Data.Ix (Ix)

import Grafo_Grado_de_un_vertice (grado)

import Grafo_Grafos_completos (completo)

import Test.Hspec (Spec, hspec, it, shouldBe)

regular :: (Ix v,Num p) => Grafo v p -> Bool

regular g = and [grado g v == k | v <- vs]

where vs = nodos g

k = grado g (head vs)

-- La propiedad de la regularidad de todos los grafos completos de orden

-- entre m y n es

prop_CompletoRegular :: Int -> Int -> Bool

prop_CompletoRegular m n =

and [regular (completo x) | x <- [m..n]]

-- La comprobación es

-- λ> prop_CompletoRegular 1 30

-- True

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

regular g1 `shouldBe` True

it "e2" $

regular g2 `shouldBe` False

it "e3" $

regular (completo 4) `shouldBe` True

where

g1, g2 :: Grafo Int Int

g1 = creaGrafo' D (1,3) [(1,2),(2,3),(3,1)]

g2 = creaGrafo' ND (1,3) [(1,2),(2,3)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- Finished in 0.0006 seconds

-- 3 examples, 0 failures

Soluciones en Python

from src.Grafo_Grado_de_un_vertice import grado
from src.Grafo_Grafos_completos import completo
from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos


def regular(g: Grafo) -> bool:
    vs = nodos(g)
    k = grado(g, vs[0])
    return all(grado(g, v) == k for v in vs)

# La propiedad de la regularidad de todos los grafos completos de orden
# entre m y n es
def prop_CompletoRegular(m: int, n: int) -> bool:
    return all(regular(completo(x)) for x in range(m, n + 1))

# La comprobación es
#    >>> prop_CompletoRegular(1, 30)
#    True

# Verificación
# ============

def test_regular() -> None:
    g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,3),(3,1)])
    g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,3)])
    assert regular(g1)
    assert not regular(g2)
    assert regular(completo(4))
    print("Verificado")

# La verificación es
#    >>> test_regular()
#    Verificado

from src.Grafo_Grado_de_un_vertice import grado

from src.Grafo_Grafos_completos import completo

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos

def regular(g: Grafo) -> bool:

vs = nodos(g)

k = grado(g, vs[0])

return all(grado(g, v) == k for v in vs)

# La propiedad de la regularidad de todos los grafos completos de orden

# entre m y n es

def prop_CompletoRegular(m: int, n: int) -> bool:

return all(regular(completo(x)) for x in range(m, n + 1))

# La comprobación es

# >>> prop_CompletoRegular(1, 30)

# True

# Verificación

# ============

def test_regular() -> None:

g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,3),(3,1)])

g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,3)])

assert regular(g1)

assert not regular(g2)

assert regular(completo(4))

print("Verificado")

# La verificación es

# >>> test_regular()

# Verificado

TAD de los grafos: Lema del apretón de manos

PorJosé A. Alonso 7-junio-202328-mayo-2023

En la teoría de grafos, se conoce como «Lema del apretón de manos» la siguiente propiedad: la suma de los grados de los vértices de g es el doble del número de aristas de g.

Comprobar con QuickCheck que para cualquier grafo g, se verifica dicha propiedad.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Grafo (Grafo, nodos)
import TAD.GrafoGenerador
import Grafo_Grado_de_un_vertice (grado)
import Grafo_Numero_de_aristas_de_un_grafo (nAristas)
import Test.QuickCheck

prop_apretonManos :: Grafo Int Int -> Bool
prop_apretonManos g =
  sum [grado g v | v <- nodos g] == 2 * nAristas g

-- La comprobación es
--    λ> quickCheck prop_apretonManos
--    +++ OK, passed 100 tests.

import TAD.Grafo (Grafo, nodos)

import TAD.GrafoGenerador

import Grafo_Grado_de_un_vertice (grado)

import Grafo_Numero_de_aristas_de_un_grafo (nAristas)

import Test.QuickCheck

prop_apretonManos :: Grafo Int Int -> Bool

prop_apretonManos g =

sum [grado g v | v <- nodos g] == 2 * nAristas g

-- La comprobación es

-- λ> quickCheck prop_apretonManos

-- +++ OK, passed 100 tests.

Soluciones en Python

from hypothesis import given

from src.Grafo_Grado_de_un_vertice import grado
from src.Grafo_Numero_de_aristas_de_un_grafo import nAristas
from src.TAD.Grafo import nodos
from src.TAD.GrafoGenerador import gen_grafo


# La propiedad es
@given(gen_grafo())
def test_apreton(g):
    assert sum((grado(g, v) for v in nodos(g))) == 2 * nAristas(g)

# La comprobación es
#    src> poetry run pytest -q Grafo_Lema_del_apreton_de_manos.py
#    1 passed in 0.32s

from hypothesis import given

from src.Grafo_Grado_de_un_vertice import grado

from src.Grafo_Numero_de_aristas_de_un_grafo import nAristas

from src.TAD.Grafo import nodos

from src.TAD.GrafoGenerador import gen_grafo

# La propiedad es

@given(gen_grafo())

def test_apreton(g):

assert sum((grado(g, v) for v in nodos(g))) == 2 * nAristas(g)

# La comprobación es

# src> poetry run pytest -q Grafo_Lema_del_apreton_de_manos.py

# 1 passed in 0.32s

TAD de los grafos: Grado de un vértice

PorJosé A. Alonso 6-junio-20233-junio-2023

El grado de un vértice v de un grafo dirigido g, es el número aristas de g que contiene a v. Si g es no dirigido, el grado de un vértice v es el número de aristas incidentes en v, teniendo en cuenta que los lazos se cuentan dos veces.

Usando el tipo abstracto de datos de los grafos, definir las funciones,

   grado :: (Ix v,Num p) => Grafo v p -> v -> Int

1	grado :: (Ix v,Num p) => Grafo v p -> v -> Int

tal que grado g v es el grado del vértice v en el grafo g. Por ejemplo,

   g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
   g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]
   g3 = creaGrafo' D  (1,3) [(1,2),(2,2),(3,1),(3,2)]
   g4 = creaGrafo' D  (1,1) [(1,1)]
   g5 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]
   g6 = creaGrafo' D  (1,3) [(1,2),(1,3),(2,3),(3,3)]
   grado g1 5 ==  4
   grado g2 5 ==  3
   grado g2 1 ==  3
   grado g3 2 ==  4
   grado g3 1 ==  2
   grado g3 3 ==  2
   grado g4 1 ==  2
   grado g6 3 ==  4
   grado g6 3 ==  4

g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

g3 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

g4 = creaGrafo' D (1,1) [(1,1)]

g5 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

g6 = creaGrafo' D (1,3) [(1,2),(1,3),(2,3),(3,3)]

grado g1 5 == 4

grado g2 5 == 3

grado g2 1 == 3

grado g3 2 == 4

grado g3 1 == 2

grado g3 3 == 2

grado g4 1 == 2

grado g6 3 == 4

Comprobar con QuickCheck que en todo grafo, el número de nodos de grado impar es par.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grado_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), dirigido, nodos, creaGrafo')
import Data.Ix (Ix)
import Grafo_Lazos_de_un_grafo (lazos)
import Grafo_Incidentes_de_un_vertice (incidentes)
import Grafo_Grados_positivos_y_negativos (gradoPos, gradoNeg)
import Test.Hspec (Spec, hspec, it, shouldBe)

grado :: (Ix v,Num p) => Grafo v p -> v -> Int
grado g v | dirigido g           = gradoNeg g v + gradoPos g v
          | (v,v) `elem` lazos g = length (incidentes g v) + 1
          | otherwise            = length (incidentes g v)

-- La propiedad es
prop_numNodosGradoImpar :: Grafo Int Int -> Bool
prop_numNodosGradoImpar g =
  even (length [v | v <- nodos g, odd (grado g v)])

-- La comprobación es
--    λ> quickCheck prop_numNodosGradoImpar
--    +++ OK, passed 100 tests.

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    grado g1 5 `shouldBe`  4
  it "e2" $
    grado g2 5 `shouldBe`  3
  it "e3" $
    grado g2 1 `shouldBe`  3
  it "e4" $
    grado g3 2 `shouldBe`  4
  it "e5" $
    grado g3 1 `shouldBe`  2
  it "e6" $
    grado g3 3 `shouldBe`  2
  it "e7" $
    grado g4 1 `shouldBe`  2
  it "e8" $
    grado g5 3 `shouldBe`  4
  it "e9" $
    grado g6 3 `shouldBe`  4
  where
    g1, g2, g3, g4, g5, g6 :: Grafo Int Int
    g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
    g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]
    g3 = creaGrafo' D  (1,3) [(1,2),(2,2),(3,1),(3,2)]
    g4 = creaGrafo' D  (1,1) [(1,1)]
    g5 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]
    g6 = creaGrafo' D  (1,3) [(1,2),(1,3),(2,3),(3,3)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--    e5
--    e6
--    e7
--    e8
--    e9
--
--    Finished in 0.0015 seconds
--    9 examples, 0 failures

module Grafo_Grado_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), dirigido, nodos, creaGrafo')

import Data.Ix (Ix)

import Grafo_Lazos_de_un_grafo (lazos)

import Grafo_Incidentes_de_un_vertice (incidentes)

import Grafo_Grados_positivos_y_negativos (gradoPos, gradoNeg)

import Test.Hspec (Spec, hspec, it, shouldBe)

grado :: (Ix v,Num p) => Grafo v p -> v -> Int

grado g v | dirigido g = gradoNeg g v + gradoPos g v

| (v,v) `elem` lazos g = length (incidentes g v) + 1

| otherwise = length (incidentes g v)

-- La propiedad es

prop_numNodosGradoImpar :: Grafo Int Int -> Bool

prop_numNodosGradoImpar g =

even (length [v | v <- nodos g, odd (grado g v)])

-- La comprobación es

-- λ> quickCheck prop_numNodosGradoImpar

-- +++ OK, passed 100 tests.

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

grado g1 5 `shouldBe` 4

it "e2" $

grado g2 5 `shouldBe` 3

it "e3" $

grado g2 1 `shouldBe` 3

it "e4" $

grado g3 2 `shouldBe` 4

it "e5" $

grado g3 1 `shouldBe` 2

it "e6" $

grado g3 3 `shouldBe` 2

it "e7" $

grado g4 1 `shouldBe` 2

it "e8" $

grado g5 3 `shouldBe` 4

it "e9" $

grado g6 3 `shouldBe` 4

where

g1, g2, g3, g4, g5, g6 :: Grafo Int Int

g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

g3 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

g4 = creaGrafo' D (1,1) [(1,1)]

g5 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

g6 = creaGrafo' D (1,3) [(1,2),(1,3),(2,3),(3,3)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- e7

-- e8

-- e9

-- Finished in 0.0015 seconds

-- 9 examples, 0 failures

Soluciones en Python

from hypothesis import given

from src.Grafo_Grados_positivos_y_negativos import gradoNeg, gradoPos
from src.Grafo_Incidentes_de_un_vertice import incidentes
from src.Grafo_Lazos_de_un_grafo import lazos
from src.TAD.Grafo import (Grafo, Orientacion, Vertice, creaGrafo_, dirigido,
                           nodos)
from src.TAD.GrafoGenerador import gen_grafo


def grado(g: Grafo, v: Vertice) -> int:
    if dirigido(g):
        return gradoNeg(g, v) + gradoPos(g, v)
    if (v, v) in lazos(g):
        return len(incidentes(g, v)) + 1
    return len(incidentes(g, v))

# La propiedad esp
@given(gen_grafo())
def test_grado1(g):
    assert len([v for v in nodos(g) if grado(g, v) % 2 == 1]) % 2 == 0

# La comprobación es
#    src> poetry run pytest -q Grafo_Grado_de_un_vertice.py
#    1 passed in 0.36s

# Verificación
# ============

def test_grado() -> None:
    g1 = creaGrafo_(Orientacion.ND, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])
    g2 = creaGrafo_(Orientacion.D, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])
    g3 = creaGrafo_(Orientacion.D, (1,3),
                    [(1,2),(2,2),(3,1),(3,2)])
    g4 = creaGrafo_(Orientacion.D, (1,1),
                    [(1,1)])
    g5 = creaGrafo_(Orientacion.ND, (1,3),
                    [(1,2),(1,3),(2,3),(3,3)])
    g6 = creaGrafo_(Orientacion.D, (1,3),
                    [(1,2),(1,3),(2,3),(3,3)])
    assert grado(g1, 5) == 4
    assert grado(g2, 5) == 3
    assert grado(g2, 1) == 3
    assert grado(g3, 2) == 4
    assert grado(g3, 1) == 2
    assert grado(g3, 3) == 2
    assert grado(g4, 1) == 2
    assert grado(g5, 3) == 4
    assert grado(g6, 3) == 4
    print("Verificado")

# La verificación es
#    >>> test_grado()
#    Verificado

from hypothesis import given

from src.Grafo_Grados_positivos_y_negativos import gradoNeg, gradoPos

from src.Grafo_Incidentes_de_un_vertice import incidentes

from src.Grafo_Lazos_de_un_grafo import lazos

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, creaGrafo_, dirigido,

nodos)

from src.TAD.GrafoGenerador import gen_grafo

def grado(g: Grafo, v: Vertice) -> int:

if dirigido(g):

return gradoNeg(g, v) + gradoPos(g, v)

if (v, v) in lazos(g):

return len(incidentes(g, v)) + 1

return len(incidentes(g, v))

# La propiedad esp

@given(gen_grafo())

def test_grado1(g):

assert len([v for v in nodos(g) if grado(g, v) % 2 == 1]) % 2 == 0

# La comprobación es

# src> poetry run pytest -q Grafo_Grado_de_un_vertice.py

# 1 passed in 0.36s

# Verificación

# ============

def test_grado() -> None:

g1 = creaGrafo_(Orientacion.ND, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])

g2 = creaGrafo_(Orientacion.D, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])

g3 = creaGrafo_(Orientacion.D, (1,3),

[(1,2),(2,2),(3,1),(3,2)])

g4 = creaGrafo_(Orientacion.D, (1,1),

[(1,1)])

g5 = creaGrafo_(Orientacion.ND, (1,3),

[(1,2),(1,3),(2,3),(3,3)])

g6 = creaGrafo_(Orientacion.D, (1,3),

[(1,2),(1,3),(2,3),(3,3)])

assert grado(g1, 5) == 4

assert grado(g2, 5) == 3

assert grado(g2, 1) == 3

assert grado(g3, 2) == 4

assert grado(g3, 1) == 2

assert grado(g3, 3) == 2

assert grado(g4, 1) == 2

assert grado(g5, 3) == 4

assert grado(g6, 3) == 4

print("Verificado")

# La verificación es

# >>> test_grado()

# Verificado

TAD de los grafos: Generadores de grafos

PorJosé A. Alonso 5-junio-20233-junio-2023

Definir un generador de grafos para comprobar propiedades de grafos con QuickCheck y hacer el tipo de los Grafos un subtipo de Arbitrary.

Usando el generador, con QuickCheck que para cualquier grafo g, las sumas de los grados positivos y la de los grados negativos de los vértices de g son iguales.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

La definición del generador es

{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module TAD.GrafoGenerador where

import TAD.Grafo (Grafo, Orientacion (D, ND), creaGrafo)
import Test.QuickCheck (Arbitrary, Gen, arbitrary, choose, vectorOf)

-- (generaGND n ps) es el grafo completo de orden n tal que los pesos
-- están determinados por ps. Por ejemplo,
--    λ> generaGND 3 [4,2,5]
--    G ND ([1,2,3],[((1,2),4),((1,3),2),((2,3),5)])
--    λ> generaGND 3 [4,-2,5]
--    G ND ([1,2,3],[((1,2),4),((2,3),5)])
generaGND :: Int -> [Int] -> Grafo Int Int
generaGND n ps  = creaGrafo ND (1,n) l3
  where l1 = [(x,y) | x <- [1..n], y <- [1..n], x < y]
        l2 = zip l1 ps
        l3 = [(x,y,z) | ((x,y),z) <- l2, z > 0]

-- (generaGD n ps) es el grafo completo de orden n tal que los pesos
-- están determinados por ps. Por ejemplo,
--    λ> generaGD 3 [4,2,5]
--    G D ([1,2,3],[((1,1),4),((1,2),2),((1,3),5)])
--    λ> generaGD 3 [4,2,5,3,7,9,8,6]
--    G D ([1,2,3],[((1,1),4),((1,2),2),((1,3),5),
--                  ((2,1),3),((2,2),7),((2,3),9),
--                  ((3,1),8),((3,2),6)])
generaGD :: Int -> [Int] -> Grafo Int Int
generaGD n ps = creaGrafo D (1,n) l3
  where l1 = [(x,y) | x <- [1..n], y <- [1..n]]
        l2 = zip l1 ps
        l3 = [(x,y,z) | ((x,y),z) <- l2, z > 0]

-- genGD es un generador de grafos dirigidos. Por ejemplo,
--    λ> sample genGD
--    G D ([1],[])
--    G D ([1,2],[((1,1),5),((2,1),4)])
--    G D ([1,2],[((1,1),3),((1,2),3)])
--    G D ([1,2,3,4,5,6],[])
--    G D ([1,2],[((2,2),16)])
--    ...
genGD :: Gen (Grafo Int Int)
genGD = do
  n <- choose (1,10)
  xs <- vectorOf (n*n) arbitrary
  return (generaGD n xs)

-- genGND es un generador de grafos dirigidos. Por ejemplo,
--    λ> sample genGND
--    G ND ([1,2,3,4,5,6,7,8],[])
--    G ND ([1],[])
--    G ND ([1,2,3,4,5],[((1,2),2),((2,3),5),((3,4),5),((3,5),5)])
--    G ND ([1,2,3,4,5],[((1,2),6),((1,3),5),((1,5),1),((3,5),9),((4,5),6)])
--    G ND ([1,2,3,4],[((1,2),5),((3,4),2)])
--    G ND ([1,2,3],[])
--    G ND ([1,2,3,4],[((1,2),5),((1,4),14),((2,4),10)])
--    G ND ([1,2,3,4,5],[((1,5),8),((4,5),5)])
--    G ND ([1,2,3,4],[((1,2),1),((1,4),4),((2,3),4),((3,4),5)])
--    G ND ([1,2,3],[((1,2),8),((1,3),8),((2,3),3)])
--    ...
genGND :: Gen (Grafo Int Int)
genGND = do
  n <- choose (1,10)
  xs <- vectorOf (n*n) arbitrary
  return (generaGND n xs)

-- genG es un generador de grafos. Por ejemplo,
--    λ> sample genG
--    G ND ([1,2,3,4,5,6],[])
--    G D ([1],[((1,1),2)])
--    G D ([1,2],[((1,1),9)])
--    ...
genG :: Gen (Grafo Int Int)
genG = do
  d <- choose (True,False)
  n <- choose (1,10)
  xs <- vectorOf (n*n) arbitrary
  if d then return (generaGD n xs)
       else return (generaGND n xs)

-- Los grafos está contenido en la clase de los objetos generables
-- aleatoriamente.
instance Arbitrary (Grafo Int Int) where
  arbitrary = genG

{-# LANGUAGE FlexibleInstances #-}

{-# OPTIONS_GHC -fno-warn-orphans #-}

module TAD.GrafoGenerador where

import TAD.Grafo (Grafo, Orientacion (D, ND), creaGrafo)

import Test.QuickCheck (Arbitrary, Gen, arbitrary, choose, vectorOf)

-- (generaGND n ps) es el grafo completo de orden n tal que los pesos

-- están determinados por ps. Por ejemplo,

-- λ> generaGND 3 [4,2,5]

-- G ND ([1,2,3],[((1,2),4),((1,3),2),((2,3),5)])

-- λ> generaGND 3 [4,-2,5]

-- G ND ([1,2,3],[((1,2),4),((2,3),5)])

generaGND :: Int -> [Int] -> Grafo Int Int

generaGND n ps = creaGrafo ND (1,n) l3

where l1 = [(x,y) | x <- [1..n], y <- [1..n], x < y]

l2 = zip l1 ps

l3 = [(x,y,z) | ((x,y),z) <- l2, z > 0]

-- (generaGD n ps) es el grafo completo de orden n tal que los pesos

-- están determinados por ps. Por ejemplo,

-- λ> generaGD 3 [4,2,5]

-- G D ([1,2,3],[((1,1),4),((1,2),2),((1,3),5)])

-- λ> generaGD 3 [4,2,5,3,7,9,8,6]

-- G D ([1,2,3],[((1,1),4),((1,2),2),((1,3),5),

-- ((2,1),3),((2,2),7),((2,3),9),

-- ((3,1),8),((3,2),6)])

generaGD :: Int -> [Int] -> Grafo Int Int

generaGD n ps = creaGrafo D (1,n) l3

where l1 = [(x,y) | x <- [1..n], y <- [1..n]]

l2 = zip l1 ps

l3 = [(x,y,z) | ((x,y),z) <- l2, z > 0]

-- genGD es un generador de grafos dirigidos. Por ejemplo,

-- λ> sample genGD

-- G D ([1],[])

-- G D ([1,2],[((1,1),5),((2,1),4)])

-- G D ([1,2],[((1,1),3),((1,2),3)])

-- G D ([1,2,3,4,5,6],[])

-- G D ([1,2],[((2,2),16)])

-- ...

genGD :: Gen (Grafo Int Int)

genGD = do

n <- choose (1,10)

xs <- vectorOf (n*n) arbitrary

return (generaGD n xs)

-- genGND es un generador de grafos dirigidos. Por ejemplo,

-- λ> sample genGND

-- G ND ([1,2,3,4,5,6,7,8],[])

-- G ND ([1],[])

-- G ND ([1,2,3,4,5],[((1,2),2),((2,3),5),((3,4),5),((3,5),5)])

-- G ND ([1,2,3,4,5],[((1,2),6),((1,3),5),((1,5),1),((3,5),9),((4,5),6)])

-- G ND ([1,2,3,4],[((1,2),5),((3,4),2)])

-- G ND ([1,2,3],[])

-- G ND ([1,2,3,4],[((1,2),5),((1,4),14),((2,4),10)])

-- G ND ([1,2,3,4,5],[((1,5),8),((4,5),5)])

-- G ND ([1,2,3,4],[((1,2),1),((1,4),4),((2,3),4),((3,4),5)])

-- G ND ([1,2,3],[((1,2),8),((1,3),8),((2,3),3)])

-- ...

genGND :: Gen (Grafo Int Int)

genGND = do

n <- choose (1,10)

xs <- vectorOf (n*n) arbitrary

return (generaGND n xs)

-- genG es un generador de grafos. Por ejemplo,

-- λ> sample genG

-- G ND ([1,2,3,4,5,6],[])

-- G D ([1],[((1,1),2)])

-- G D ([1,2],[((1,1),9)])

-- ...

genG :: Gen (Grafo Int Int)

genG = do

d <- choose (True,False)

n <- choose (1,10)

xs <- vectorOf (n*n) arbitrary

if d then return (generaGD n xs)

else return (generaGND n xs)

-- Los grafos está contenido en la clase de los objetos generables

-- aleatoriamente.

instance Arbitrary (Grafo Int Int) where

arbitrary = genG

La comprobación de la propiedad es

module Grafo_Propiedades_de_grados_positivos_y_negativos where

import TAD.Grafo (Grafo, nodos)
import TAD.GrafoGenerador
import Grafo_Grados_positivos_y_negativos (gradoPos, gradoNeg)
import Test.QuickCheck

-- La propiedad es
prop_sumaGrados :: Grafo Int Int -> Bool
prop_sumaGrados g =
  sum [gradoPos g v | v <- vs] == sum [gradoNeg g v | v <- vs]
  where vs = nodos g

-- La comprobación es
--    λ> quickCheck prop_sumaGrados
--    +++ OK, passed 100 tests.

module Grafo_Propiedades_de_grados_positivos_y_negativos where

import TAD.Grafo (Grafo, nodos)

import TAD.GrafoGenerador

import Grafo_Grados_positivos_y_negativos (gradoPos, gradoNeg)

import Test.QuickCheck

-- La propiedad es

prop_sumaGrados :: Grafo Int Int -> Bool

prop_sumaGrados g =

sum [gradoPos g v | v <- vs] == sum [gradoNeg g v | v <- vs]

where vs = nodos g

-- La comprobación es

-- λ> quickCheck prop_sumaGrados

-- +++ OK, passed 100 tests.

Soluciones en Python

La definición del generador es

from hypothesis import strategies as st
from hypothesis.strategies import composite

from src.TAD.Grafo import Orientacion, creaGrafo_


# Generador de aristas. Por ejemplo,
#    >>> gen_aristas(5).example()
#    [(2, 5), (4, 5), (1, 2), (2, 3), (4, 1)]
#    >>> gen_aristas(5).example()
#    [(3, 4)]
#    >>> gen_aristas(5).example()
#    [(5, 3), (3, 2), (1, 3), (5, 2)]
@composite
def gen_aristas(draw, n):
    as_ = draw(st.lists(st.tuples(st.integers(1,n),
                                  st.integers(1,n)),
                        unique=True))
    return as_

# Generador de grafos no dirigidos. Por ejemplo,
#    >>> gen_grafoND().example()
#    G ND ([1, 2, 3, 4, 5], [(1, 4), (5, 5)])
#    >>> gen_grafoND().example()
#    G ND ([1], [])
#    >>> gen_grafoND().example()
#    G ND ([1, 2, 3, 4, 5, 6, 7, 8], [(7, 7)])
#    >>> gen_grafoND().example()
#    G ND ([1, 2, 3, 4, 5, 6], [(1, 3), (2, 4), (3, 3), (3, 5)])
@composite
def gen_grafoND(draw):
    n = draw(st.integers(1,10))
    as_ = [(x, y) for (x, y ) in draw(gen_aristas(n)) if x <= y]
    return creaGrafo_(Orientacion.ND, (1,n), as_)

# Generador de grafos dirigidos. Por ejemplo,
#    >>> gen_grafoD().example()
#    G D ([1, 2, 3, 4], [(3, 3), (4, 1)])
#    >>> gen_grafoD().example()
#    G D ([1, 2], [(1, 1), (2, 1), (2, 2)])
#    >>> gen_grafoD().example()
#    G D ([1, 2], [])
@composite
def gen_grafoD(draw):
    n = draw(st.integers(1,10))
    as_ = draw(gen_aristas(n))
    return creaGrafo_(Orientacion.D, (1,n), as_)

# Generador de grafos. Por ejemplo,
#    >>> gen_grafo().example()
#    G ND ([1, 2, 3, 4, 5, 6, 7], [(1, 3)])
#    >>> gen_grafo().example()
#    G D ([1], [])
#    >>> gen_grafo().example()
#    G D ([1, 2, 3, 4, 5, 6, 7], [(1, 3), (3, 4), (5, 5)])
@composite
def gen_grafo(draw):
    o = draw(st.sampled_from([Orientacion.D, Orientacion.ND]))
    if o == Orientacion.ND:
        return draw(gen_grafoND())
    return draw(gen_grafoD())

from hypothesis import strategies as st

from hypothesis.strategies import composite

from src.TAD.Grafo import Orientacion, creaGrafo_

# Generador de aristas. Por ejemplo,

# >>> gen_aristas(5).example()

# [(2, 5), (4, 5), (1, 2), (2, 3), (4, 1)]

# >>> gen_aristas(5).example()

# [(3, 4)]

# >>> gen_aristas(5).example()

# [(5, 3), (3, 2), (1, 3), (5, 2)]

@composite

def gen_aristas(draw, n):

as_ = draw(st.lists(st.tuples(st.integers(1,n),

st.integers(1,n)),

unique=True))

return as_

# Generador de grafos no dirigidos. Por ejemplo,

# >>> gen_grafoND().example()

# G ND ([1, 2, 3, 4, 5], [(1, 4), (5, 5)])

# >>> gen_grafoND().example()

# G ND ([1], [])

# >>> gen_grafoND().example()

# G ND ([1, 2, 3, 4, 5, 6, 7, 8], [(7, 7)])

# >>> gen_grafoND().example()

# G ND ([1, 2, 3, 4, 5, 6], [(1, 3), (2, 4), (3, 3), (3, 5)])

@composite

def gen_grafoND(draw):

n = draw(st.integers(1,10))

as_ = [(x, y) for (x, y ) in draw(gen_aristas(n)) if x <= y]

return creaGrafo_(Orientacion.ND, (1,n), as_)

# Generador de grafos dirigidos. Por ejemplo,

# >>> gen_grafoD().example()

# G D ([1, 2, 3, 4], [(3, 3), (4, 1)])

# >>> gen_grafoD().example()

# G D ([1, 2], [(1, 1), (2, 1), (2, 2)])

# >>> gen_grafoD().example()

# G D ([1, 2], [])

@composite

def gen_grafoD(draw):

n = draw(st.integers(1,10))

as_ = draw(gen_aristas(n))

return creaGrafo_(Orientacion.D, (1,n), as_)

# Generador de grafos. Por ejemplo,

# >>> gen_grafo().example()

# G ND ([1, 2, 3, 4, 5, 6, 7], [(1, 3)])

# >>> gen_grafo().example()

# G D ([1], [])

# >>> gen_grafo().example()

# G D ([1, 2, 3, 4, 5, 6, 7], [(1, 3), (3, 4), (5, 5)])

@composite

def gen_grafo(draw):

o = draw(st.sampled_from([Orientacion.D, Orientacion.ND]))

if o == Orientacion.ND:

return draw(gen_grafoND())

return draw(gen_grafoD())

La comprobación de la propiedad es

from hypothesis import given

from src.Grafo_Grados_positivos_y_negativos import gradoNeg, gradoPos
from src.TAD.Grafo import nodos
from src.TAD.GrafoGenerador import gen_grafo


# La propiedad es
@given(gen_grafo())
def test_sumaGrados(g):
    vs = nodos(g)
    assert sum((gradoPos(g, v) for v in vs)) == sum((gradoNeg(g, v) for v in vs))

# La comprobación es
#    src> poetry run pytest -q Grafo_Propiedades_de_grados_positivos_y_negativos.py
#    1 passed in 0.31s

from hypothesis import given

from src.Grafo_Grados_positivos_y_negativos import gradoNeg, gradoPos

from src.TAD.Grafo import nodos

from src.TAD.GrafoGenerador import gen_grafo

# La propiedad es

@given(gen_grafo())

def test_sumaGrados(g):

vs = nodos(g)

assert sum((gradoPos(g, v) for v in vs)) == sum((gradoNeg(g, v) for v in vs))

# La comprobación es

# src> poetry run pytest -q Grafo_Propiedades_de_grados_positivos_y_negativos.py

# 1 passed in 0.31s

TAD de los grafos: Grado positivo y negativo de un vértice

PorJosé A. Alonso 2-junio-20233-junio-2023

El grado positivo de un vértice v de un grafo g es el número de vértices de g adyacentes con v y su grado negativo es el número de vértices de g incidentes con v.

Usando el tipo abstracto de datos de los grafos, definir las funciones,

   gradoPos :: (Ix v,Num p) => Grafo v p -> v -> Int
   gradoNeg :: (Ix v,Num p) => Grafo v p -> v -> Int

1 2	gradoPos :: (Ix v,Num p) => Grafo v p -> v -> Int gradoNeg :: (Ix v,Num p) => Grafo v p -> v -> Int

tales que
+ gradoPos g v es el grado positivo del vértice v en el grafo g. Por ejemplo,

     λ> g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
     λ> g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]
     λ> gradoPos g1 5
     4
     λ> gradoPos g2 5
     0
     λ> gradoPos g2 1
     3

λ> g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

λ> g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

λ> gradoPos g1 5

λ> gradoPos g2 5

λ> gradoPos g2 1

gradoNeg g v es el grado negativo del vértice v en el grafo g. Por ejemplo,

     λ> gradoNeg g1 5
     4
     λ> gradoNeg g2 5
     3
     λ> gradoNeg g2 1
     0

λ> gradoNeg g1 5

λ> gradoNeg g2 5

λ> gradoNeg g2 1

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grados_positivos_y_negativos where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')
import Data.Ix (Ix)
import Grafo_Incidentes_de_un_vertice (incidentes)
import Test.Hspec (Spec, hspec, it, shouldBe)

-- 1ª definición de gradoPos
gradoPos :: (Ix v,Num p) => Grafo v p -> v -> Int
gradoPos g v = length (adyacentes g v)

-- 2ª definición de gradoPos
gradoPos2 :: (Ix v,Num p) => Grafo v p -> v -> Int
gradoPos2 g = length . adyacentes g

-- 1ª definición de gradoNeg
gradoNeg :: (Ix v,Num p) => Grafo v p -> v -> Int
gradoNeg g v = length (incidentes g v)

-- 2ª definición de gradoNeg
gradoNeg2 :: (Ix v,Num p) => Grafo v p -> v -> Int
gradoNeg2 g = length . incidentes g

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    gradoPos g1 5 `shouldBe` 4
  it "e2" $
    gradoPos g2 5 `shouldBe` 0
  it "e3" $
    gradoPos g2 1 `shouldBe` 3
  it "e4" $
    gradoNeg g1 5 `shouldBe` 4
  it "e5" $
    gradoNeg g2 5 `shouldBe` 3
  it "e6" $
    gradoNeg g2 1 `shouldBe` 0
  it "e7" $
    gradoPos2 g1 5 `shouldBe` 4
  it "e8" $
    gradoPos2 g2 5 `shouldBe` 0
  it "e9" $
    gradoPos2 g2 1 `shouldBe` 3
  it "e10" $
    gradoNeg2 g1 5 `shouldBe` 4
  it "e11" $
    gradoNeg2 g2 5 `shouldBe` 3
  it "e12" $
    gradoNeg2 g2 1 `shouldBe` 0
  where
    g1, g2 :: Grafo Int Int
    g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
    g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

-- La verificación es
--    λ> verifica
--
--    def. 1
--      e1
--      e2
--      e3
--      e4
--      e5
--      e6
--    def. 2
--      e1
--      e2
--      e3
--      e4
--      e5
--      e6
--
--    Finished in 0.0013 seconds
--    12 examples, 0 failures

module Grafo_Grados_positivos_y_negativos where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')

import Data.Ix (Ix)

import Grafo_Incidentes_de_un_vertice (incidentes)

import Test.Hspec (Spec, hspec, it, shouldBe)

-- 1ª definición de gradoPos

gradoPos :: (Ix v,Num p) => Grafo v p -> v -> Int

gradoPos g v = length (adyacentes g v)

-- 2ª definición de gradoPos

gradoPos2 :: (Ix v,Num p) => Grafo v p -> v -> Int

gradoPos2 g = length . adyacentes g

-- 1ª definición de gradoNeg

gradoNeg :: (Ix v,Num p) => Grafo v p -> v -> Int

gradoNeg g v = length (incidentes g v)

-- 2ª definición de gradoNeg

gradoNeg2 :: (Ix v,Num p) => Grafo v p -> v -> Int

gradoNeg2 g = length . incidentes g

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

gradoPos g1 5 `shouldBe` 4

it "e2" $

gradoPos g2 5 `shouldBe` 0

it "e3" $

gradoPos g2 1 `shouldBe` 3

it "e4" $

gradoNeg g1 5 `shouldBe` 4

it "e5" $

gradoNeg g2 5 `shouldBe` 3

it "e6" $

gradoNeg g2 1 `shouldBe` 0

it "e7" $

gradoPos2 g1 5 `shouldBe` 4

it "e8" $

gradoPos2 g2 5 `shouldBe` 0

it "e9" $

gradoPos2 g2 1 `shouldBe` 3

it "e10" $

gradoNeg2 g1 5 `shouldBe` 4

it "e11" $

gradoNeg2 g2 5 `shouldBe` 3

it "e12" $

gradoNeg2 g2 1 `shouldBe` 0

where

g1, g2 :: Grafo Int Int

g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

-- La verificación es

-- λ> verifica

-- def. 1

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- def. 2

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- Finished in 0.0013 seconds

-- 12 examples, 0 failures

Soluciones en Python

from src.Grafo_Incidentes_de_un_vertice import incidentes
from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_


def gradoPos(g: Grafo, v: Vertice) -> int:
    return len(adyacentes(g, v))

def gradoNeg(g: Grafo, v: Vertice) -> int:
    return len(incidentes(g, v))

# Verificación
# ============

def test_GradoPosNeg() -> None:
    g1 = creaGrafo_(Orientacion.ND, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])
    g2 = creaGrafo_(Orientacion.D, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])
    assert gradoPos(g1, 5) == 4
    assert gradoPos(g2, 5) == 0
    assert gradoPos(g2, 1) == 3
    assert gradoNeg(g1, 5) == 4
    assert gradoNeg(g2, 5) == 3
    assert gradoNeg(g2, 1) == 0
    print("Verificado")

# La verificación es
#    >>> test_GradoPosNeg()
#    Verificado

from src.Grafo_Incidentes_de_un_vertice import incidentes

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

def gradoPos(g: Grafo, v: Vertice) -> int:

return len(adyacentes(g, v))

def gradoNeg(g: Grafo, v: Vertice) -> int:

return len(incidentes(g, v))

# Verificación

# ============

def test_GradoPosNeg() -> None:

g1 = creaGrafo_(Orientacion.ND, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])

g2 = creaGrafo_(Orientacion.D, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])

assert gradoPos(g1, 5) == 4

assert gradoPos(g2, 5) == 0

assert gradoPos(g2, 1) == 3

assert gradoNeg(g1, 5) == 4

assert gradoNeg(g2, 5) == 3

assert gradoNeg(g2, 1) == 0

print("Verificado")

# La verificación es

# >>> test_GradoPosNeg()

# Verificado

TAD de los grafos: Número de aristas de un grafo

PorJosé A. Alonso 1-junio-20233-junio-2023

Usando el tipo abstracto de datos de los grafos, definir la función,

   nAristas :: (Ix v,Num p) => Grafo v p ->  Int

1	nAristas :: (Ix v,Num p) => Grafo v p -> Int

tal que nAristas g es el número de aristas del grafo g. Si g es no dirigido, las aristas de v1 a v2 y de v2 a v1 sólo se cuentan una vez. Por ejemplo,

   λ> g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
   λ> g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]
   λ> g3 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]
   λ> g4 = creaGrafo' ND (1,4) [(1,1),(1,2),(3,3)]
   λ> nAristas g1
   8
   λ> nAristas g2
   7
   λ> nAristas g3
   4
   λ> nAristas g4
   3
   λ> nAristas (completo 4)
   6
   λ> nAristas (completo 5)
   10

λ> g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

λ> g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

λ> g3 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

λ> g4 = creaGrafo' ND (1,4) [(1,1),(1,2),(3,3)]

λ> nAristas g1

λ> nAristas g2

λ> nAristas g3

λ> nAristas g4

λ> nAristas (completo 4)

λ> nAristas (completo 5)

Definir la función

   prop_nAristasCompleto :: Int -> Bool

1	prop_nAristasCompleto :: Int -> Bool

tal que prop_nAristasCompleto n se verifica si el número de aristas del grafo completo de orden n es n*(n-1)/2 y, usando la función, comprobar que la propiedad se cumple para n de 1 a 20.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Numero_de_aristas_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), dirigido, aristas, creaGrafo')
import Data.Ix (Ix)
import Grafo_Lazos_de_un_grafo (nLazos)
import Grafo_Grafos_completos (completo)
import Test.Hspec (Spec, hspec, it, shouldBe, describe)

-- 1ª solución
-- ===========

nAristas :: (Ix v,Num p) => Grafo v p ->  Int
nAristas g | dirigido g = length (aristas g)
           | otherwise  = (length (aristas g) + nLazos g) `div` 2

-- 2ª solución
-- ===========

nAristas2 :: (Ix v,Num p) => Grafo v p ->  Int
nAristas2 g | dirigido g = length (aristas g)
            | otherwise  = length [(x,y) | ((x,y),_) <- aristas g, x <= y]

-- Propiedad
-- =========

prop_nAristasCompleto :: Int -> Bool
prop_nAristasCompleto n =
  nAristas (completo n) == n*(n-1) `div` 2

-- La comprobación es
--    λ> and [prop_nAristasCompleto n | n <- [1..20]]
--    True

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  describe "def. 1" $ specG nAristas
  describe "def. 2" $ specG nAristas2

specG :: (Grafo Int Int -> Int) -> Spec
specG nAristas' = do
  it "e1" $
    nAristas' g1 `shouldBe` 8
  it "e2" $
    nAristas' g2 `shouldBe` 7
  it "e3" $
    nAristas' g3 `shouldBe` 4
  it "e4" $
    nAristas' g4 `shouldBe` 3
  it "e5" $
    nAristas' (completo 4) `shouldBe` 6
  it "e6" $
    nAristas' (completo 5) `shouldBe` 10
  where
    g1, g2, g3, g4 :: Grafo Int Int
    g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]
    g2 = creaGrafo' D  (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]
    g3 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]
    g4 = creaGrafo' ND (1,4) [(1,1),(1,2),(3,3)]

-- La verificación es
--    λ> verifica
--
--    def. 1
--      e1
--      e2
--      e3
--      e4
--      e5
--      e6
--    def. 2
--      e1
--      e2
--      e3
--      e4
--      e5
--      e6
--
--    Finished in 0.0013 seconds
--    12 examples, 0 failures

module Grafo_Numero_de_aristas_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), dirigido, aristas, creaGrafo')

import Data.Ix (Ix)

import Grafo_Lazos_de_un_grafo (nLazos)

import Grafo_Grafos_completos (completo)

import Test.Hspec (Spec, hspec, it, shouldBe, describe)

-- 1ª solución

-- ===========

nAristas :: (Ix v,Num p) => Grafo v p -> Int

nAristas g | dirigido g = length (aristas g)

| otherwise = (length (aristas g) + nLazos g) `div` 2

-- 2ª solución

-- ===========

nAristas2 :: (Ix v,Num p) => Grafo v p -> Int

nAristas2 g | dirigido g = length (aristas g)

| otherwise = length [(x,y) | ((x,y),_) <- aristas g, x <= y]

-- Propiedad

-- =========

prop_nAristasCompleto :: Int -> Bool

prop_nAristasCompleto n =

nAristas (completo n) == n*(n-1) `div` 2

-- La comprobación es

-- λ> and [prop_nAristasCompleto n | n <- [1..20]]

-- True

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

describe "def. 1" $ specG nAristas

describe "def. 2" $ specG nAristas2

specG :: (Grafo Int Int -> Int) -> Spec

specG nAristas' = do

it "e1" $

nAristas' g1 `shouldBe` 8

it "e2" $

nAristas' g2 `shouldBe` 7

it "e3" $

nAristas' g3 `shouldBe` 4

it "e4" $

nAristas' g4 `shouldBe` 3

it "e5" $

nAristas' (completo 4) `shouldBe` 6

it "e6" $

nAristas' (completo 5) `shouldBe` 10

where

g1, g2, g3, g4 :: Grafo Int Int

g1 = creaGrafo' ND (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)]

g2 = creaGrafo' D (1,5) [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)]

g3 = creaGrafo' ND (1,3) [(1,2),(1,3),(2,3),(3,3)]

g4 = creaGrafo' ND (1,4) [(1,1),(1,2),(3,3)]

-- La verificación es

-- λ> verifica

-- def. 1

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- def. 2

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- Finished in 0.0013 seconds

-- 12 examples, 0 failures

Soluciones en Python

from src.Grafo_Grafos_completos import completo
from src.Grafo_Lazos_de_un_grafo import nLazos
from src.TAD.Grafo import Grafo, Orientacion, aristas, creaGrafo_, dirigido

# 1ª solución
# ===========

def nAristas(g: Grafo) -> int:
    if dirigido(g):
        return len(aristas(g))
    return (len(aristas(g)) + nLazos(g)) // 2

# 2ª solución
# ===========

def nAristas2(g: Grafo) -> int:
    if dirigido(g):
        return len(aristas(g))
    return len([(x, y) for ((x,y),_) in aristas(g) if x <= y])

# Propiedad
# =========

def prop_nAristasCompleto(n: int) -> bool:
    return nAristas(completo(n)) == n*(n-1) // 2

# La comprobación es
#    >>> all(prop_nAristasCompleto(n) for n in range(1, 21))
#    True

# Verificación
# ============

def test_nAristas() -> None:
    g1 = creaGrafo_(Orientacion.ND, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])
    g2 = creaGrafo_(Orientacion.D, (1,5),
                    [(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])
    g3 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(1,3),(2,3),(3,3)])
    g4 = creaGrafo_(Orientacion.ND, (1,4), [(1,1),(1,2),(3,3)])
    for nAristas_ in [nAristas, nAristas2]:
        assert nAristas_(g1) == 8
        assert nAristas_(g2) == 7
        assert nAristas_(g3) == 4
        assert nAristas_(g4) == 3
        assert nAristas_(completo(4)) == 6
        assert nAristas_(completo(5)) == 10
    print("Verificado")

# La verificación es
#    >>> test_nAristas()
#    Verificado

from src.Grafo_Grafos_completos import completo

from src.Grafo_Lazos_de_un_grafo import nLazos

from src.TAD.Grafo import Grafo, Orientacion, aristas, creaGrafo_, dirigido

# 1ª solución

# ===========

def nAristas(g: Grafo) -> int:

if dirigido(g):

return len(aristas(g))

return (len(aristas(g)) + nLazos(g)) // 2

# 2ª solución

# ===========

def nAristas2(g: Grafo) -> int:

if dirigido(g):

return len(aristas(g))

return len([(x, y) for ((x,y),_) in aristas(g) if x <= y])

# Propiedad

# =========

def prop_nAristasCompleto(n: int) -> bool:

return nAristas(completo(n)) == n*(n-1) // 2

# La comprobación es

# >>> all(prop_nAristasCompleto(n) for n in range(1, 21))

# True

# Verificación

# ============

def test_nAristas() -> None:

g1 = creaGrafo_(Orientacion.ND, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,5),(4,5)])

g2 = creaGrafo_(Orientacion.D, (1,5),

[(1,2),(1,3),(1,5),(2,4),(2,5),(4,3),(4,5)])

g3 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(1,3),(2,3),(3,3)])

g4 = creaGrafo_(Orientacion.ND, (1,4), [(1,1),(1,2),(3,3)])

for nAristas_ in [nAristas, nAristas2]:

assert nAristas_(g1) == 8

assert nAristas_(g2) == 7

assert nAristas_(g3) == 4

assert nAristas_(g4) == 3

assert nAristas_(completo(4)) == 6

assert nAristas_(completo(5)) == 10

print("Verificado")

# La verificación es

# >>> test_nAristas()

# Verificado

TAD de los grafos: Lazos de un grafo

PorJosé A. Alonso 31-mayo-20233-junio-2023

Usando el tipo abstracto de datos de los grafos, definir las funciones,

   lazos  :: (Ix v,Num p) => Grafo v p -> [(v,v)]
   nLazos :: (Ix v,Num p) => Grafo v p -> Int

1 2	lazos :: (Ix v,Num p) => Grafo v p -> [(v,v)] nLazos :: (Ix v,Num p) => Grafo v p -> Int

tales que

lazos g es el conjunto de los lazos (es decir, aristas cuyos extremos son iguales) del grafo g. Por ejemplo,

     λ> ej1 = creaGrafo' D (1,3) [(1,1),(2,3),(3,2),(3,3)]
     λ> ej2 = creaGrafo' ND (1,3) [(2,3),(3,1)]
     λ> lazos ej1
     [(1,1),(3,3)]
     λ> lazos ej2
     []

λ> ej1 = creaGrafo' D (1,3) [(1,1),(2,3),(3,2),(3,3)]

λ> ej2 = creaGrafo' ND (1,3) [(2,3),(3,1)]

λ> lazos ej1

[(1,1),(3,3)]

λ> lazos ej2

[]

nLazos g es el número de lazos del grafo g. Por ejemplo,

     λ> nLazos ej1
     2
     λ> nLazos ej2
     0

λ> nLazos ej1

λ> nLazos ej2

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Lazos_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, aristaEn, creaGrafo')
import Data.Ix (Ix)
import Test.Hspec (Spec, hspec, it, shouldBe)

lazos :: (Ix v,Num p) => Grafo v p -> [(v,v)]
lazos g = [(x,x) | x <- nodos g, aristaEn g (x,x)]

nLazos :: (Ix v,Num p) => Grafo v p ->  Int
nLazos = length . lazos

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    lazos ej1 `shouldBe` [(1,1),(3,3)]
  it "e2" $
    lazos ej2 `shouldBe` []
  it "e3" $
    nLazos ej1 `shouldBe` 2
  it "e4" $
    nLazos ej2 `shouldBe` 0
  where
    ej1, ej2 :: Grafo Int Int
    ej1 = creaGrafo' D (1,3) [(1,1),(2,3),(3,2),(3,3)]
    ej2 = creaGrafo' ND (1,3) [(2,3),(3,1)]

-- La verificación es
--      λ> verifica
--
--      e1
--      e2
--      e3
--      e4
--
--      Finished in 0.0005 seconds
--      4 examples, 0 failures

module Grafo_Lazos_de_un_grafo where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, aristaEn, creaGrafo')

import Data.Ix (Ix)

import Test.Hspec (Spec, hspec, it, shouldBe)

lazos :: (Ix v,Num p) => Grafo v p -> [(v,v)]

lazos g = [(x,x) | x <- nodos g, aristaEn g (x,x)]

nLazos :: (Ix v,Num p) => Grafo v p -> Int

nLazos = length . lazos

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

lazos ej1 `shouldBe` [(1,1),(3,3)]

it "e2" $

lazos ej2 `shouldBe` []

it "e3" $

nLazos ej1 `shouldBe` 2

it "e4" $

nLazos ej2 `shouldBe` 0

where

ej1, ej2 :: Grafo Int Int

ej1 = creaGrafo' D (1,3) [(1,1),(2,3),(3,2),(3,3)]

ej2 = creaGrafo' ND (1,3) [(2,3),(3,1)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- Finished in 0.0005 seconds

-- 4 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, aristaEn, creaGrafo_,
                           nodos)


def lazos(g: Grafo) -> list[tuple[Vertice, Vertice]]:
    return [(x, x) for x in nodos(g) if aristaEn(g, (x, x))]

def nLazos(g: Grafo) -> int:
    return len(lazos(g))

# Verificación
# ============

def test_lazos() -> None:
    ej1 = creaGrafo_(Orientacion.D, (1,3), [(1,1),(2,3),(3,2),(3,3)])
    ej2 = creaGrafo_(Orientacion.ND, (1,3), [(2,3),(3,1)])
    assert lazos(ej1) == [(1,1),(3,3)]
    assert lazos(ej2) == []
    assert nLazos(ej1) == 2
    assert nLazos(ej2) == 0
    print("Verificado")

# La verificación es
#    >>> test_lazos()
#    Verificado

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, aristaEn, creaGrafo_,

nodos)

def lazos(g: Grafo) -> list[tuple[Vertice, Vertice]]:

return [(x, x) for x in nodos(g) if aristaEn(g, (x, x))]

def nLazos(g: Grafo) -> int:

return len(lazos(g))

# Verificación

# ============

def test_lazos() -> None:

ej1 = creaGrafo_(Orientacion.D, (1,3), [(1,1),(2,3),(3,2),(3,3)])

ej2 = creaGrafo_(Orientacion.ND, (1,3), [(2,3),(3,1)])

assert lazos(ej1) == [(1,1),(3,3)]

assert lazos(ej2) == []

assert nLazos(ej1) == 2

assert nLazos(ej2) == 0

print("Verificado")

# La verificación es

# >>> test_lazos()

# Verificado

TAD de los grafos: Contiguos de un vértice

PorJosé A. Alonso 30-mayo-20233-junio-2023

En un un grafo g, los contiguos de un vértice v es el conjuntos de vértices x de g tales que x es adyacente o incidente con v.

Usando el tipo abstracto de datos de los grafos, definir la función,

   contiguos :: (Ix v,Num p) => Grafo v p -> v -> [v]

1	contiguos :: (Ix v,Num p) => Grafo v p -> v -> [v]

tal que contiguos g v es el conjunto de los vértices de g contiguos con el vértice v. Por ejemplo,

   λ> g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]
   λ> contiguos g1 1
   [2,3]
   λ> contiguos g1 2
   [2,1,3]
   λ> contiguos g1 3
   [1,2]
   λ> g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]
   λ> contiguos g2 1
   [2,3]
   λ> contiguos g2 2
   [1,2,3]
   λ> contiguos g2 3
   [1,2]

λ> g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

λ> contiguos g1 1

[2,3]

λ> contiguos g1 2

[2,1,3]

λ> contiguos g1 3

[1,2]

λ> g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

λ> contiguos g2 1

[2,3]

λ> contiguos g2 2

[1,2,3]

λ> contiguos g2 3

[1,2]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Contiguos_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')
import Grafo_Incidentes_de_un_vertice (incidentes)
import Data.List (nub)
import Data.Ix
import Test.Hspec

contiguos :: (Ix v,Num p) => Grafo v p -> v -> [v]
contiguos g v = nub (adyacentes g v ++ incidentes g v)

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    contiguos g1 1 `shouldBe` [2,3]
  it "e2" $
    contiguos g1 2 `shouldBe` [2,1,3]
  it "e3" $
    contiguos g1 3 `shouldBe` [1,2]
  it "e4" $
    contiguos g2 1 `shouldBe` [2,3]
  it "e5" $
    contiguos g2 2 `shouldBe` [1,2,3]
  it "e6" $
    contiguos g2 3 `shouldBe` [1,2]
  where
    g1, g2 :: Grafo Int Int
    g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]
    g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--    e5
--    e6
--
--    Finished in 0.0005 seconds
--    6 examples, 0 failures

module Grafo_Contiguos_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), adyacentes, creaGrafo')

import Grafo_Incidentes_de_un_vertice (incidentes)

import Data.List (nub)

import Data.Ix

import Test.Hspec

contiguos :: (Ix v,Num p) => Grafo v p -> v -> [v]

contiguos g v = nub (adyacentes g v ++ incidentes g v)

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

contiguos g1 1 `shouldBe` [2,3]

it "e2" $

contiguos g1 2 `shouldBe` [2,1,3]

it "e3" $

contiguos g1 3 `shouldBe` [1,2]

it "e4" $

contiguos g2 1 `shouldBe` [2,3]

it "e5" $

contiguos g2 2 `shouldBe` [1,2,3]

it "e6" $

contiguos g2 3 `shouldBe` [1,2]

where

g1, g2 :: Grafo Int Int

g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- Finished in 0.0005 seconds

-- 6 examples, 0 failures

Soluciones en Python

from src.Grafo_Incidentes_de_un_vertice import incidentes
from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_


def contiguos(g: Grafo, v: Vertice) -> list[Vertice]:
    return list(set(adyacentes(g, v) + incidentes(g, v)))

# Verificación
# ============

def test_contiguos() -> None:
    g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,2),(3,1),(3,2)])
    g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,2),(3,1),(3,2)])
    assert contiguos(g1, 1) == [2, 3]
    assert contiguos(g1, 2) == [1, 2, 3]
    assert contiguos(g1, 3) == [1, 2]
    assert contiguos(g2, 1) == [2, 3]
    assert contiguos(g2, 2) == [1, 2, 3]
    assert contiguos(g2, 3) == [1, 2]
    print("Verificado")

# La verificación es
#    >>> test_contiguos()
#    Verificado

from src.Grafo_Incidentes_de_un_vertice import incidentes

from src.TAD.Grafo import Grafo, Orientacion, Vertice, adyacentes, creaGrafo_

def contiguos(g: Grafo, v: Vertice) -> list[Vertice]:

return list(set(adyacentes(g, v) + incidentes(g, v)))

# Verificación

# ============

def test_contiguos() -> None:

g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,2),(3,1),(3,2)])

g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,2),(3,1),(3,2)])

assert contiguos(g1, 1) == [2, 3]

assert contiguos(g1, 2) == [1, 2, 3]

assert contiguos(g1, 3) == [1, 2]

assert contiguos(g2, 1) == [2, 3]

assert contiguos(g2, 2) == [1, 2, 3]

assert contiguos(g2, 3) == [1, 2]

print("Verificado")

# La verificación es

# >>> test_contiguos()

# Verificado

TAD de los grafos: Incidentes de un vértice

PorJosé A. Alonso 29-mayo-20233-junio-2023

En un un grafo g, los incidentes de un vértice v es el conjuntos de vértices x de g para los que hay un arco (o una arista) de x a v; es decir, que v es adyacente a x.

Usando el tipo abstracto de datos de los grafos, definir la función,

   incidentes :: (Ix v,Num p) => (Grafo v p) -> v -> [v]

1	incidentes :: (Ix v,Num p) => (Grafo v p) -> v -> [v]

tal que incidentes g v es la lista de los vértices incidentes en el vértice v. Por ejemplo,

   λ> g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]
   λ> incidentes g1 1
   [3]
   λ> incidentes g1 2
   [1,2,3]
   λ> incidentes g1 3
   []
   λ> g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]
   λ> incidentes g2 1
   [2,3]
   λ> incidentes g2 2
   [1,2,3]
   λ> incidentes g2 3
   [1,2]

λ> g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

λ> incidentes g1 1

[3]

λ> incidentes g1 2

[1,2,3]

λ> incidentes g1 3

[]

λ> g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

λ> incidentes g2 1

[2,3]

λ> incidentes g2 2

[1,2,3]

λ> incidentes g2 3

[1,2]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Incidentes_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos,  adyacentes, creaGrafo')
import Data.Ix
import Test.Hspec

incidentes :: (Ix v,Num p) => Grafo v p -> v -> [v]
incidentes g v = [x | x <- nodos g, v `elem` adyacentes g x]

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    incidentes g1 1 `shouldBe` [3]
  it "e2" $
    incidentes g1 2 `shouldBe` [1,2,3]
  it "e3" $
    incidentes g1 3 `shouldBe` []
  it "e4" $
    incidentes g2 1 `shouldBe` [2,3]
  it "e5" $
    incidentes g2 2 `shouldBe` [1,2,3]
  it "e6" $
    incidentes g2 3 `shouldBe` [1,2]
  where
    g1, g2 :: Grafo Int Int
    g1  = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]
    g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

-- La verificación es
--    λ> verifica
--
--    e1
--    e2
--    e3
--    e4
--    e5
--    e6
--
--    Finished in 0.0005 seconds
--    6 examples, 0 failures

module Grafo_Incidentes_de_un_vertice where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, adyacentes, creaGrafo')

import Data.Ix

import Test.Hspec

incidentes :: (Ix v,Num p) => Grafo v p -> v -> [v]

incidentes g v = [x | x <- nodos g, v `elem` adyacentes g x]

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

incidentes g1 1 `shouldBe` [3]

it "e2" $

incidentes g1 2 `shouldBe` [1,2,3]

it "e3" $

incidentes g1 3 `shouldBe` []

it "e4" $

incidentes g2 1 `shouldBe` [2,3]

it "e5" $

incidentes g2 2 `shouldBe` [1,2,3]

it "e6" $

incidentes g2 3 `shouldBe` [1,2]

where

g1, g2 :: Grafo Int Int

g1 = creaGrafo' D (1,3) [(1,2),(2,2),(3,1),(3,2)]

g2 = creaGrafo' ND (1,3) [(1,2),(2,2),(3,1),(3,2)]

-- La verificación es

-- λ> verifica

-- e1

-- e2

-- e3

-- e4

-- e5

-- e6

-- Finished in 0.0005 seconds

-- 6 examples, 0 failures

Soluciones en Python

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, creaGrafo_,
                           nodos)


def incidentes(g: Grafo, v: Vertice) -> list[Vertice]:
    return [x for x in nodos(g) if v in adyacentes(g, x)]

# Verificación
# ============

def test_incidentes() -> None:
    g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,2),(3,1),(3,2)])
    g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,2),(3,1),(3,2)])
    assert incidentes(g1,1) == [3]
    assert incidentes(g1,2) == [1, 2, 3]
    assert incidentes(g1,3) == []
    assert incidentes(g2, 1) == [2, 3]
    assert incidentes(g2, 2) == [1, 2, 3]
    assert incidentes(g2, 3) == [1, 2]
    print("Verificado")

# La verificación es
#    >>> test_incidentes()
#    Verificado

from src.TAD.Grafo import (Grafo, Orientacion, Vertice, adyacentes, creaGrafo_,

nodos)

def incidentes(g: Grafo, v: Vertice) -> list[Vertice]:

return [x for x in nodos(g) if v in adyacentes(g, x)]

# Verificación

# ============

def test_incidentes() -> None:

g1 = creaGrafo_(Orientacion.D, (1,3), [(1,2),(2,2),(3,1),(3,2)])

g2 = creaGrafo_(Orientacion.ND, (1,3), [(1,2),(2,2),(3,1),(3,2)])

assert incidentes(g1,1) == [3]

assert incidentes(g1,2) == [1, 2, 3]

assert incidentes(g1,3) == []

assert incidentes(g2, 1) == [2, 3]

assert incidentes(g2, 2) == [1, 2, 3]

assert incidentes(g2, 3) == [1, 2]

print("Verificado")

# La verificación es

# >>> test_incidentes()

# Verificado

TAD de los grafos: Número de vértices

PorJosé A. Alonso 26-mayo-20233-junio-2023

Usando el tipo abstracto de datos de los grafos, definir la función,

   nVertices :: (Ix v, Num p) => Grafo v p ->  Int

1	nVertices :: (Ix v, Num p) => Grafo v p -> Int

tal que nVertices g es el número de vértices del grafo g. Por ejemplo,

   nVertices (creaGrafo' D (1,5) [(1,2),(3,1)])   ==  5
   nVertices (creaGrafo' ND (2,4) [(1,2),(3,1)])  ==  3

1 2	nVertices (creaGrafo' D (1,5) [(1,2),(3,1)]) == 5 nVertices (creaGrafo' ND (2,4) [(1,2),(3,1)]) == 3

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Numero_de_vertices where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')
import Data.Ix

nVertices :: (Ix v, Num p) => Grafo v p ->  Int
nVertices = length . nodos

module Grafo_Numero_de_vertices where

import TAD.Grafo (Grafo, Orientacion (D, ND), nodos, creaGrafo')

import Data.Ix

nVertices :: (Ix v, Num p) => Grafo v p -> Int

nVertices = length . nodos

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos


def nVertices(g: Grafo) -> int:
    return len(nodos(g))

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_, nodos

def nVertices(g: Grafo) -> int:

return len(nodos(g))

TAD de los grafos: Grafos ciclos

PorJosé A. Alonso 25-mayo-20233-junio-2023

El ciclo de orden n, C(n), es un grafo no dirigido cuyo conjunto de vértices es {1,…,n} y las aristas son

   (1,2), (2,3), ..., (n-1,n), (n,1)

1	(1,2), (2,3), ..., (n-1,n), (n,1)

Usando el tipo abstracto de datos de los grafos, definir la función,

   grafoCiclo :: Int -> Grafo Int Int

1	grafoCiclo :: Int -> Grafo Int Int

tal que (grafoCiclo n) es el grafo ciclo de orden n. Por ejemplo,

   λ> grafoCiclo 3
   G ND ([1,2,3],[(1,2),(1,3),(2,3)])

1 2	λ> grafoCiclo 3 G ND ([1,2,3],[(1,2),(1,3),(2,3)])

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Grafo_Grafos_ciclos where

import TAD.Grafo (Grafo, Orientacion (ND), creaGrafo')
import Test.Hspec (Spec, hspec, it, shouldBe)

grafoCiclo :: Int -> Grafo Int Int
grafoCiclo n =
  creaGrafo' ND (1,n) ((n,1):[(x,x+1) | x <- [1..n-1]])

-- Verificación
-- ============

verifica :: IO ()
verifica = hspec spec

spec :: Spec
spec = do
  it "e1" $
    show (grafoCiclo 3) `shouldBe`
    "G ND ([1,2,3],[(1,2),(1,3),(2,3)])"

-- La verificación es
--    λ> verifica
--
--    e1
--
--    Finished in 0.0006 seconds
--    1 example, 0 failures

module Grafo_Grafos_ciclos where

import TAD.Grafo (Grafo, Orientacion (ND), creaGrafo')

import Test.Hspec (Spec, hspec, it, shouldBe)

grafoCiclo :: Int -> Grafo Int Int

grafoCiclo n =

creaGrafo' ND (1,n) ((n,1):[(x,x+1) | x <- [1..n-1]])

-- Verificación

-- ============

verifica :: IO ()

verifica = hspec spec

spec :: Spec

spec = do

it "e1" $

show (grafoCiclo 3) `shouldBe`

"G ND ([1,2,3],[(1,2),(1,3),(2,3)])"

-- La verificación es

-- λ> verifica

-- e1

-- Finished in 0.0006 seconds

-- 1 example, 0 failures

Soluciones en Python

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_


def grafoCiclo(n: int) -> Grafo:
    return creaGrafo_(Orientacion.ND,
                      (1, n),
                      [(n,1)] + [(x, x + 1) for x in range(1, n)])

# Verificación
# ============

def test_grafoCiclo() -> None:
    assert str(grafoCiclo(3)) == \
        "G ND ([1, 2, 3], [(1, 2), (1, 3), (2, 3)])"
    print("Verificado")

# La verificación es
#    >>> test_grafoCiclo()
#    Verificado

from src.TAD.Grafo import Grafo, Orientacion, creaGrafo_

def grafoCiclo(n: int) -> Grafo:

return creaGrafo_(Orientacion.ND,

(1, n),

[(n,1)] + [(x, x + 1) for x in range(1, n)])

# Verificación

# ============

def test_grafoCiclo() -> None:

assert str(grafoCiclo(3)) == \

"G ND ([1, 2, 3], [(1, 2), (1, 3), (2, 3)])"

print("Verificado")

# La verificación es

# >>> test_grafoCiclo()

# Verificado

1. El tipo abstracto de datos de las colas de prioridad

2. Las colas de prioridad en Haskell

2.1. El tipo abstracto de datos de las colas de prioridad en Haskell

2.2. Implementación de las colas de prioridad mediante listas

3. Las colas de prioridad en Python

3.1. El tipo abstracto de las colas de prioridad en Python

3.2. Implementación de las colas de prioridad mediante listas

Entradas recientes

Buscar

Correo electrónico