RTP2: Enunciado

2do
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2014
Recuperatorio del trabajo práctico 2: Diseño
Normativa
Límite de entrega: martes 25 de noviembre hasta las 22:00 hs. Enviar a algo2.dc@gmail.com
Normas de entrega: Ver Información sobre la cursada en el sitio Web de la materia.
(http://www.dc.uba.ar/materias/aed2/2014/2c/informacion)
Versión: 1.2 del 22 de noviembre de 2014 (ver RTP2_Changelog)
Enunciado
El objetivo de este trabajo práctico es, en primer lugar, corregir todos los errores marcados en la corrección
1
del TP2, manteniendo el contexto de uso y los órdenes de complejidad requeridos en el enunciado del mismo .
En segundo lugar, para este recuperatorio se modicó el TAD CiudadRobótica con respecto al TP original
para poder conocer:
Cuál es la característica que estuvo involucrada en la mayor cantidad de infracciones a lo largo de toda
la historia de la ciudad.Más precisamente, decimos que una característica estuvo involucrada en una
infracción si pertenece al conjunto de características del robot que cometió la infracción.
función_ambulancia, modelo_XZ-18}
Por ejemplo, si un robot tiene las características {
y comete
una infracción, ambas características resultan involucradas.
Cuántas inspecciones se realizaron en cada estación.
Estos cambios están especicados como son deseados, y debe realizarse el diseño teniendo en cuenta estos
agregados. Sugerimos que confíen en la axiomatización más que en el castellano.
Contexto de uso y complejidades requeridas
Se requiere que las operaciones exportadas de los TADs tengan una contraparte en los módulos diseñados.
Además, se debe cumplir con los mismos requerimientos de complejidad que en el TP2 original, pero con los
siguientes agregados según la modicación del TAD CiudadRobótica:
tagMásInvolucrado c O(1)
#inspecciones e, c O(|e|)
|e|
mover u, e2, c O(|e1 | + |e2| + log Ne
( ) es
(
(
) es
) es
.
, donde
es la longitud del nombre de la estación
1
+ log Ne2 + CTu ),
e.
donde:
• e1 es la estación donde se encuentra el robot antes de moverse, y e2 es la estación a la que se mueve.
• CTu es el cardinal del conjunto de tags del robot con rur u en la ciudad c, es decir, CTu = #(tags(u, c))
1
Con excepción de la función mover
1/7
2do
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2014
Requisitos y consideraciones
Todas las operaciones auxiliares deben ser especicadas formalmente según las herramientas vistas en
clase. Agregar comentarios necesarios para entender la forma en la cual deben ser utilizadas para su
correcto funcionamiento.
Todos los algoritmos
deben
tener su desarrollo que justique los órdenes de complejidad. Si algún paso es
no trivial pueden hacer notas a continuación del mismo.
Cuando se formalicen los invariantes y funciones de abstracción,
deben
identicar cada parte de la fórmula
del Rep y comentar en castellano lo que describe.
Tener en cuenta que las complejidades son en peor caso. Soluciones más ecientes serán bien recibidas.
Tengan en cuenta que hay estructuras que pueden servir para más de una nalidad, sobre todos los
contenedores.
Pueden crear módulos adicionales si así lo necesitan.
Cuentan con los siguiente TADs y módulos:
•
Char que representan los posibles caracteres. Siendo un tipo enumerado de 256 valores. con funciones
ord
•
•
•
ord−1
Char a N at.
V ector(Char) y su comparación:
• < • (in s1 : String, in s2 : String) → bool con costo O(mı́n(|s1 |, |s2 |)).
y
para la correspondencia de cada
String como sinónimo de
Todos los denidos en el apunte de TADs básicos.
Todos los denidos en el apunte de módulos básicos.
2/7
2do
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2014
Especicación
Aclaraciones de nomenclatura:
Las características de los robots se llaman
Se usa la notación
{x1 , x2 , . . . , xn }
tags.
para denotar el conjunto:
Ag(x1 , Ag(x2 ,
. . .,
Ag(xn ,
∅) . . .))
Se respeta la siguiente convención para los nombres de las variables:
7→
7
→
7
→
7
→
7
→
7
→
7
→
7
→
e
t
ts
u
us
r
m
c
estaciones
tags
conjuntos de tags
unidades robóticas (rurs)
conjuntos de unidades robóticas
restricciones
mapas
ciudades
TAD letra es enumerado ('_', 'a', 'b', ..., 'z', '0', '1', ..., '9')
TAD string es secu(letra)
TAD estación es string
TAD tag es string
TAD rur es nat
TAD Restricción
exporta
todos los generadores, todos los observadores
géneros
restricción
igualdad observacional

r1 =obs r2 ⇐⇒
(∀ts : conj(tag))
(∀r1, r2 : restricción) 
verica?(ts, r1) =obs


verica?(ts,
observadores básicos
verica?
: conj(tag)
×
restricción
−→
bool
−→
−→
−→
−→
restricción
generadores
h•i
• AND •
• OR •
NOT •
: tag
: restricción
: restricción
×
×
restricción
restricción
: restricción
axiomas
(∀t
: tag, ∀ts : conj(tag), ∀r, r1, r2 :
hti)
≡ t ∈ ts
verica?(ts, r1 AND r2) ≡ verica?(ts, r1) ∧
verica?(ts, r1 OR r2)
≡ verica?(ts, r1) ∨
verica?(ts, NOT r )
≡ ¬verica?(ts, r)
restricción
restricción
restricción
restricción)
verica?(ts,
verica?(ts,
verica?(ts,
Fin TAD
TAD Mapa
exporta
géneros
todos los generadores, todos los observadores
mapa
3/7
r2)
r2)
r2)
2do
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2014
igualdad observacional


m1 =obs m2 ⇐⇒
estaciones(m1)





(∀m1, m2 : mapa) 





∧L
(∀e1, e2
:
=obs
estaciones(m2)
estación)
({e1, e2}
⊆
estaciones(m1)
⇒L conectadas?(e1, e2, m1) =obs conectadas?(e1, e2, m2))
: estación)
({e1, e2} ⊆ estaciones(m1) ∧L conectadas?(e1, e2, m1)
⇒L restricción(e1, e2, m1) =obs restricción(e1, e2, m2)
∧L
(∀e1, e2











observadores básicos
estaciones
−→
−→
: mapa
conj(estación)
conectadas? : estación
e1 ×
estación
e2 ×
mapa
m
restricción
: estación
e1 ×
estación
e2 ×
mapa
m
{{e1, e2} ⊆
:
−→ mapa
e × mapa m
−→ mapa
{e 6∈ estaciones(m)}
e1 × estación e2 × restricción r × mapa m −→ mapa
{{e1, e2} ⊆ estaciones(m) ∧L ¬conectadas?(e1, e2, m)}
bool
{{e1, e2} ⊆ estaciones(m)}
−→ restricción
estaciones(m) ∧L conectadas?(e1, e2, m)}
generadores
vacío
agregar
: estación
conectar
: estación
axiomas
(∀m
:
mapa,
∀r :
restricción,
estaciones(vacío)
estaciones(agregar(e,
m))
e2, m))
estaciones(conectar(e1,
conectadas?(e1,
conectadas?(e1,
restricción(e1,
e2,
e2,
e2,
restricción(e1, e2,
agregar(e,
∀ : e, e1, e2, e10 , e20 :
estación)
≡ ∅
≡ Ag(e, estaciones(m))
≡ estaciones(m)
m))
≡ ¬(e1 = e ∧ e2 = e) ∨L conectadas?(e1, e2, m)
0
e20 , r, m)) ≡ {e1, e2} = {e10 , e20 } ∨L conectadas?(e1, e2, m)
conectar(e1 ,
agregar(e,
m))
0
0
conectar(e1 , e2 , r , m))
≡
≡
restricción(e1,
if
e2, m)
{e1, e2} = {e10 , e20 }
r
then
else
Fin TAD
restricción(e1,
e2, m)
TAD CiudadRobótica
exporta
todos los generadores, todos los observadores, estaciones, tagMásInvolucrado
géneros
ciudad
igualdad observacional












(∀c1, c2 : ciudad) 












c1 =obs c2 ⇐⇒
próximoRUR(c1)
∧L
=obs próximoRUR(c2)
∧ mapa(c1) =obs mapa(c2)
∧ robots(c1) =obs robots(c2)
∧ tagsHistóricos(c1) =obs tagsHistóricos(c2)
∧L (∀e: estación)
(e ∈ estaciones(c1)
⇒L #inspecciones(e,c1) =obs #inspecciones(e,c2))
∧
(∀t : tag)
(t ∈ tagsHistóricos(c1)
⇒L #infraccionesXtag(t,c1) =obs #infraccionesXtag(t,c2))
∧
(∀u : rur) (u ∈ robots(c1) ⇒L


estación(u, c1) =obs estación(u, c2)
 ∧ tags(u, c1) =obs tags(u, c2)

∧ #infracciones(u, c1) =obs #infracciones(u, c2))
4/7























2do
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2014
observadores básicos
c
−→
c
−→
ciudad c
−→
rur u × ciudad c
−→
rur u × ciudad c
−→
rur u × ciudad c
−→
tag t × ciudad c
−→
estación e × ciudad c −→
ciudad c
−→
próximoRUR
: ciudad
rur
mapa
: ciudad
mapa
robots
:
conj(rur)
estación
:
tags
:
#infracciones
:
#infraccionesXtag :
#inspecciones
:
tagsHistóricos
:
∈
∈
{u ∈
estación
conj(tag)
nat
{t
nat
∈
nat
{u
robots(c)}
{u
robots(c)}
robots(c)}
tagsHistóricos(c)}
{e
∈
estaciones(c)}
{e
∈
estaciones(c)}
conj(tag)
generadores
: mapa
entrar
: conj(tag)
mover
: rur
inspección :
−→
−→
−→
m
crear
ts × estación e × ciudad c
u × estación e × ciudad c
{u ∈ robots(c) ∧ e ∈ estaciones(c)
estación e × ciudad c
∧L
ciudad
ciudad
ciudad
c), e, mapa(c))}
e ∈ estaciones(c) }
conectadas?(estación(u,
−→
ciudad
{
otras operaciones
−→
−→
c
estaciones
: ciudad
robotsEn
: estación
e×
ciudad
c
conj(estación)
conj(rur)
{e ∈
ltrarRobotsEn
: conj(rur)
elMásInfractor
: conj(rur)
másInfractor
:
tagMásInvolucrado
:
ltrarTagMásInvolucrado :
axiomas
(∀c
:
ciudad,
∀m
us ×
us ×
e×
estación
ciudad
ciudad
c
c −→
{e ∈
−→
estaciones(c)}
conj(rur)
estaciones(c)
∧ us ⊆
{¬∅?(us) ∧ us ⊆ robots(c)}
rur u1 × rur u2 × ciudad c
−→ rur
{{u1, u2} ⊆ robots(c)}
ciudad c
−→ tag
{∃t ∈ tagsHistóricos(c) ∧L #infraccionesXtag(t,c) > 0}
ciudad c × conj(tag) ts × tag t
−→ tag
: mapa,
∀u, u0 , u1, u2 :
rur,
≡ 0
≡ próximoRUR(c)
≡ próximoRUR(c)
≡ próximoRUR(c)
próximoRUR(crear(m))
próximoRUR(entrar(ts,
e, c))
e, c))
próximoRUR(inspección(e, c))
próximoRUR(mover(u,
∀ts :
conj(tag),
∀us :
conj(rur))
+ 1
≡ m
e, c)) ≡ mapa(c)
mapa(mover(u, e, c))
≡ mapa(c)
mapa(inspección(e, c)) ≡ mapa(c)
mapa(crear(m))
mapa(entrar(ts,
robots(crear(m))
robots(entrar(ts,
e, c))
e, c))
robots(inspección(e, c))
robots(mover(u,
≡ ∅
≡ Ag(próximoRUR(c), robots(c))
≡ robots(c)
≡ robots(e, c) \ if ∅?(robotsEn(e, c))
∨L #infracciones(elMásInfractor(robotsEn(e, c), c))
∅
= 0
then
else
{elMásInfractor(robotsEn(e,
e, c)) ≡
e, c)) ≡
estación(u, inspección(e, c)) ≡
estación(u, entrar(ts,
0
estación(u, mover(u ,
tags(u, entrar(ts,
0
tags(u, mover(u ,
e, c))
e, c))
≡
≡
robots(c)}
rur
if
c), c)}
if
if
u = próximoRUR(c) then e else estación(u, c)
u = u0 then e else estación(u, c) estación(u, c)
u=
tags(u,
próximoRUR(c)
c)
5/7
then
ts
else
tags(u,
c)
2do
Algoritmos y Estructuras de Datos II - DC - UBA
tags(u, inspección(e,
c)) ≡
tags(u,
cuatrimestre de 2014
c)
≡
≡
#infracciones(u, entrar(ts,
e, c))
#infracciones(u, mover(u , e, c))
0
if
if
u = próximoRUR(c) then 0
u = u0 then
β (¬ (verica?(tags(u, c),
else
#infracciones(u,
restricción(estación(u,
else
c), e,
c)
mapa(c)))))
0
+ #infracciones(u, c)
0
#infracciones(u, inspección(u ,
e, c)) ≡
#infraccionesXtag(t, entrar(ts,
e, c))
#infracciones(u,
≡
if
c)
t ∈ ts ∧ ¬(t ∈
0
tagsHistóricos(c))
then
else
#infraccionesXtag(t, mover(u,
≡
e, c))
if
#infraccionesXtag(t,
c)
t ∈ tags(u, c) then
β (¬ (verica?(tags(u, c),
restricción(estación(u,
else
c), e,
mapa(c)))))
0
+ #infraccionesXtag(t, c)
#infraccionesXtag(t, inspección(u,
e, c)) ≡
#inspecciones(e, crear(m))
0
#inspecciones(e, entrar(ts,
e , c))
e0 , c))
0
#inspecciones(e, inspección(u, e , c))
#inspecciones(e, mover(u,
e, c))
tagsHistóricos(mover(u, e, c))
tagsHistóricos(inspección(u, e, c))
robotsEn(e,
c)
ltrarRobotsEn(us,
e, c)
≡
≡
≡
≡
c)
≡ 0
≡ #inspecciones(e, c)
≡ #inspecciones(e, c)
≡ if e = e0 then 1 else 0
+ #inspecciones(e, c)
estaciones(mapa(c))
ltrarRobotsEn(robots(c),
if
∅?(us)
∅
else
if
elMásInfractor(us,
c)
≡ ∅
≡ tagsHistóricos(c) ∪ts
≡ tagsHistóricos(c)
≡ tagsHistóricos(c)
tagsHistóricos(crear(m))
tagsHistóricos(entrar(ts,
estaciones(c)
#infraccionesXtag(t,
if
then
e , c)
estación(dameUno(us),
c)
ltrarRobotsEn(sinUno(us),
#(us) = 1
= e
e, c)
then
{dameUno(us)}
else
then
dameUno(us)
else
másInfractor(dameUno(us),
elMásInfractor(sinUno(us,
másInfractor(u1,
u2, c) ≡
c)),
c)
if
#infracciones(u1,
∨
then
c) > #infracciones(u2, c)
c) = #infracciones(u2, c) ∧ u1 < u2)
(#infracciones(u1,
u1
else
u2
ltrarTagMásInvolucrado( c,
tagMásInvolucrado(c)
≡
sinUno(tagsHistóricos(c)),
dameUno(tagsHistóricos(c)))
6/7
∅
∪
2do
Algoritmos y Estructuras de Datos II - DC - UBA
ltrarTagMásInvolucrado(c,
ts, t) ≡
if
∅?(ts)
t
else
if
cuatrimestre de 2014
then
#infraccionesXtag(dameUno(ts),
c) >
#infraccionesXtag(t,
c)
∨
(#infraccionesXtag(dameUno(ts),
then
∧
dameUno(ts)
c)
= #infraccionesXtag(t,
< t)
ltrarTagMásInvolucrado(c, sinUno(ts), dameUno(ts))
else
Fin TAD
ltrarTagMásInvolucrado(c, sinUno(ts),
7/7
t)
c)