6 dynamic programming

Programación Dinámica
Análisis y Diseño de Algoritmos
Análisis y Diseño de Algoritmos

Introducción
Introducción

Elementos de la programación dinámica
Elementos de la programación dinámica

Principio de
Principio de optimalidad
optimalidad de
de Bellman
Bellman

Definición recursiva de la solución óptima

Cálculo de la solución óptima
Cálculo de la solución óptima

Ejemplos
Ejemplos

Multiplicación encadenada de matrices

Subsecuencia
Subsecuencia de mayor longitud (LCS)
de mayor longitud (LCS)

Selección de actividades con pesos

Problema de la mochila
Problema de la mochila

Caminos mínimos: Algoritmos de Floyd y
Caminos mínimos: Algoritmos de Floyd y Bellman
Bellman-
-Ford
Ford

Distancia de edición

Aplicaciones
Aplicaciones 1
1

Esta técnica se aplica sobre problemas que presentan
Esta técnica se aplica sobre problemas que presentan
las siguientes características:
las siguientes características:

Subproblemas
Subproblemas optimales
optimales:
: La solución óptima a un
La solución óptima a un
problema puede ser definida en función de soluciones
óptimas a
óptimas a subproblemas
subproblemas de tamaño menor.
de tamaño menor.

Solapamiento entre
Solapamiento entre subproblemas
subproblemas:
: Al plantear la
Al plantear la
solución recursiva del problema, un mismo problema
solución recursiva del problema, un mismo problema
se resuelve más de una vez.
se resuelve más de una vez.
2
2
Enfoque ascendente (
Enfoque ascendente (bottom
bottom-
-up):
up):

Primero se calculan las soluciones óptimas para
Primero se calculan las soluciones óptimas para
problemas de tamaño pequeño.
problemas de tamaño pequeño.

Luego, utilizando dichas soluciones, encuentra
Luego, utilizando dichas soluciones, encuentra
soluciones a problemas de mayor tamaño.
Clave: Memorización
Clave: Memorización
Almacenar las soluciones de los
Almacenar las soluciones de los subproblemas
subproblemas en
en
alguna estructura de datos para reutilizarlas
alguna estructura de datos para reutilizarlas
posteriormente. De esa forma, se consigue un
posteriormente. De esa forma, se consigue un
algoritmo más eficiente que la fuerza bruta, que
algoritmo más eficiente que la fuerza bruta, que
resuelve el mismo
resuelve el mismo subproblema
subproblema una y otra vez.
una y otra vez.
3
3

Memorización
Memorización
Para evitar calcular lo mismo varias veces:
Para evitar calcular lo mismo varias veces:

Cuando se calcula una solución, ésta se almacena.
Cuando se calcula una solución, ésta se almacena.

Antes de realizar una llamada recursiva para un
Antes de realizar una llamada recursiva para un
subproblema
subproblema Q, se comprueba si la solución ha sido
Q, se comprueba si la solución ha sido
subproblema
subproblema Q, se comprueba si la solución ha sido
Q, se comprueba si la solución ha sido
obtenida previamente:
obtenida previamente:

Si no ha sido obtenida, se hace la llamada recursiva
Si no ha sido obtenida, se hace la llamada recursiva
y, antes de devolver la solución, ésta se almacena.
y, antes de devolver la solución, ésta se almacena.

Si ya ha sido previamente calculada, se recupera la
Si ya ha sido previamente calculada, se recupera la
solución directamente (no hace falta calcularla).
solución directamente (no hace falta calcularla).

Usualmente, se utiliza una matriz que se rellena
Usualmente, se utiliza una matriz que se rellena
conforme las soluciones a los
conforme las soluciones a los subproblemas
subproblemas son
son
calculados (espacio vs. tiempo).
calculados (espacio vs. tiempo). 4
4
Uso de la programación dinámica:
Uso de la programación dinámica:
1.
1. Caracterizar la estructura de una solución óptima.
Caracterizar la estructura de una solución óptima.
2.
2. Definir de forma recursiva la solución óptima.
Definir de forma recursiva la solución óptima.
2.
2. Definir de forma recursiva la solución óptima.
Definir de forma recursiva la solución óptima.
3.
3. Calcular la solución óptima de forma ascendente.
Calcular la solución óptima de forma ascendente.
4.
4. Construir la solución óptima a partir de los datos
Construir la solución óptima a partir de los datos
almacenados al obtener soluciones parciales.
almacenados al obtener soluciones parciales.
5
5

Estrategias de diseño
Estrategias de diseño
Algoritmos
Algoritmos greedy:
greedy:
Se
Se construye
construye la
la solución
solución incrementalmente
incrementalmente,
, utilizando
utilizando
un
un criterio
criterio de
de optimización
optimización local.
local.
Programación
Programación dinámica
dinámica:
:
Se
Se descompone
descompone el
el problema
problema en
en subproblemas
subproblemas
solapados
solapados y se
y se va
va construyendo
construyendo la
la solución
solución con
con las
las
soluciones
soluciones de
de esos
esos subproblemas
subproblemas.
.
Divide y
Divide y vencerás
vencerás:
:
Se
Se descompone
descompone el
el problema
problema en
en subproblemas
subproblemas
independientes
independientes y se
y se combinan
combinan las
las soluciones
soluciones de
de
esos
esos subproblemas
subproblemas.
.
6
6
Principio de
Principio de Optimalidad
Optimalidad
Para poder emplear programación dinámica, una
Para poder emplear programación dinámica, una
secuencia óptima debe cumplir la condición de que
secuencia óptima debe cumplir la condición de que
cada una de sus
cada una de sus subsecuencias
subsecuencias también sea óptima:
también sea óptima:
Dado un problema P con n elementos,
si la secuencia óptima es e
si la secuencia óptima es e1
1e
e2
2...
...e
ek
k...e
...en
n entonces:
entonces:

e
e1
1e
e2
2...
...e
ek
k es solución al problema P considerando los
es solución al problema P considerando los
k primeros elementos.
k primeros elementos.

e
ek+1
k+1...e
...en
n es solución al problema P considerando los
es solución al problema P considerando los
elementos desde k+1 hasta n.
elementos desde k+1 hasta n.
7
7

Principio de
Optimalidad
En otras palabras:
En otras palabras:
La solución óptima de cualquier instancia no trivial
La solución óptima de cualquier instancia no trivial
de un problema es una combinación de las soluciones
de un problema es una combinación de las soluciones
óptimas de sus
óptimas de sus subproblemas
subproblemas.
.
óptimas de sus
óptimas de sus subproblemas
subproblemas.
.

Se busca la solución óptima a un problema
Se busca la solución óptima a un problema
como un proceso de decisión “
como un proceso de decisión “multietápico
multietápico”.
”.

Se toma una decisión en cada paso, pero ésta
Se toma una decisión en cada paso, pero ésta
depende de las soluciones a los
depende de las soluciones a los subproblemas
subproblemas
que lo componen.
que lo componen.
8
8
Principio de
Optimalidad
Un poco de historia:
Un poco de historia: Bellman
Bellman, años 50…
, años 50…
Enfoque está inspirado en la teoría de control:
Enfoque está inspirado en la teoría de control:
Se obtiene la política óptima para un problema de
Se obtiene la política óptima para un problema de
control con n etapas basándose en una política óptima
control con n etapas basándose en una política óptima
para un problema similar, pero de n
para un problema similar, pero de n-
-1 etapas.
1 etapas.
para un problema similar, pero de n
para un problema similar, pero de n-
-1 etapas.
1 etapas.
Etimología: Programación dinámica = Planificación temporal
Etimología: Programación dinámica = Planificación temporal
En una época “hostil” a la investigación matemática,
En una época “hostil” a la investigación matemática, Bellman
Bellman
buscó un nombre llamativo que evitase posibles confrontaciones:
buscó un nombre llamativo que evitase posibles confrontaciones:

“it's impossible to use dynamic in a pejorative sense”
“it's impossible to use dynamic in a pejorative sense”

“something not even a Congressman could object to”
“something not even a Congressman could object to”
Richard E. Bellman: “Eye of the Hurricane: An Autobiography”
Richard E. Bellman: “Eye of the Hurricane: An Autobiography”
9
9

Principio de
Optimalidad
Principio de
Optimalidad de
de Bellman
Bellman
[
[Bellman, R.E.: “Dynamic Programming”. Princeton University Press, 1957]
Bellman, R.E.: “Dynamic Programming”. Princeton University Press, 1957]
“
“Una
Una política
política óptima
óptima tiene
tiene la
la propiedad
propiedad de
de que
que,
,
sean
sean cuales
cuales sea el
sea el estado
estado inicial
inicial y la
y la decisión
decisión inicial
inicial,
,
sean
sean cuales
cuales sea el
sea el estado
estado inicial
inicial y la
y la decisión
decisión inicial
inicial,
,
las
las decisiones
decisiones restantes
restantes deben
deben constituir
constituir una
una solucíón
solucíón
óptima
óptima con
con respecto
respecto al
al estado
estado resultante
resultante de la
de la primera
primera
decisión
decisión”.
”.
En
En Informática
Informática, un
, un problema
problema que
que puede
puede descomponerse
descomponerse
de
de esta
esta forma se dice
forma se dice que
que presenta
presenta subestructuras
subestructuras
optimales
optimales (la base de los
(la base de los algoritmos
algoritmos greedy y de la
greedy y de la
programación
programación dinámica
dinámica).
). 10
10
Principio de
Optimalidad
Principio de
Optimalidad de
de Bellman
Bellman
[
El principio de
El principio de optimalidad
optimalidad se
se verifica
verifica
si
si toda
toda solución
solución óptima
óptima a un
a un problema
problema está
está compuesta
compuesta
si
si toda
toda solución
solución óptima
óptima a un
a un problema
problema está
está compuesta
compuesta
por
por soluciones
soluciones óptimas
óptimas de
de sus
sus subproblemas
subproblemas.
.
¡
¡Ojo
Ojo!
!
El principio de
El principio de optimalidad
optimalidad no
no nos
nos dice
dice que
que,
,
si
si tenemos
tenemos las
las soluciones
soluciones óptimas
óptimas de los
de los subproblemas
subproblemas,
,
entonces
entonces podamos
podamos combinarlas
combinarlas para
para obtener
obtener la
la solución
solución
óptima
óptima del
del problema
problema original…
original…
11
11

Principio de
Optimalidad
Principio de
Optimalidad de
de Bellman
Bellman
[
Ejemplo
Ejemplo:
: Cambio
Cambio en
en monedas
monedas

La
La solución
solución óptima
óptima para
para 0.07
0.07 euros
euros
es
es 0.05 + 0.02
0.05 + 0.02 euros
euros.
.
es
es 0.05 + 0.02
0.05 + 0.02 euros
euros.
.

La
La solución
solución óptima
óptima para
para 0.06
0.06 euros
euros
es
es 0.05 + 0.01
0.05 + 0.01 euros
euros.
.

La
La solución
solución óptima
óptima para
para 0.13
0.13 euros
euros
no
no es
es (0.05 + 2) + (0.05 + 0.01)
(0.05 + 2) + (0.05 + 0.01) euros
euros.
.
Sin embargo,
Sin embargo, sí
sí que
que existe
existe alguna
alguna forma de
forma de
descomponer
descomponer 0.13
0.13 euros
euros de
de tal
tal forma
forma que
que las
las
soluciones
soluciones óptimas
óptimas a los
a los subproblemas
subproblemas nos
nos den
den
una
una solución
solución óptima
óptima (
(p.ej
p.ej. 0.11 y 0.02
. 0.11 y 0.02 euros
euros).
).
12
12
Definición del problema…
Definición del problema…
Para aplicar programación dinámica:
Para aplicar programación dinámica:
1.
1. Se comprueba que se cumple el principio de
Se comprueba que se cumple el principio de
optimalidad
optimalidad de
de Bellman
Bellman, para lo que hay que
, para lo que hay que
encontrar la “estructura” de la solución.
2.
2. Se define recursivamente la solución óptima del
Se define recursivamente la solución óptima del
problema (en función de los valores de las soluciones
problema (en función de los valores de las soluciones
para
para subproblemas
subproblemas de menor tamaño).
de menor tamaño).
13
13

… y cálculo de la solución óptima
… y cálculo de la solución óptima
3.
3. Se calcula el valor de la solución óptima utilizando un
Se calcula el valor de la solución óptima utilizando un
enfoque ascendente:
enfoque ascendente:

Se determina el conjunto de
Se determina el conjunto de subproblemas
subproblemas que
que
hay que resolver (el tamaño de la tabla).
hay que resolver (el tamaño de la tabla).

Se identifican los
Se identifican los subproblemas
subproblemas con una
con una

Se identifican los
Se identifican los subproblemas
subproblemas con una
con una
solución trivial (casos base).
solución trivial (casos base).

Se van calculando los valores de soluciones
Se van calculando los valores de soluciones
más complejas a partir de los valores
más complejas a partir de los valores
previamente calculados.
previamente calculados.
4.
4. Se determina la solución óptima
Se determina la solución óptima
a partir de los datos almacenados en la tabla.
a partir de los datos almacenados en la tabla.
14
14
Ejemplos
Ejemplos
Sucesión de
Sucesión de Fibonacci
Fibonacci

Implementación recursiva: O(
Implementación recursiva: O(ϕ
ϕn
n)
)

Implementación usando programación dinámica:
Implementación usando programación dinámica: Θ
Θ(n)
(n)
)
2
(
)
1
(
)
( −
+
−
= n
fib
n
fib
n
fib
if
if (n == 0)
(n == 0) return
return 0;
0;
else
else if
if (n == 1)
(n == 1) return
return 1;
1;
else
else {
{
previo = 0; actual = 1;
previo = 0; actual = 1;
for
for (i=1; in; i++) {
(i=1; in; i++) {
fib
fib = previo + actual;
= previo + actual;
previo = actual; actual =
previo = actual; actual = fib
fib;
;
}
}
return
return actual;
actual;
}
} 15
15

Ejemplos
Ejemplos
Números combinatorios:
Combinaciones de n sobre p

Implementación inmediata…
Implementación inmediata…
)!
(
!
!
p
n
p
n
p
n
−
=









Implementación usando programación dinámica…
Implementación usando programación dinámica…
Triángulo de Pascal
Triángulo de Pascal
16
16







 −
+








−
−
=








p
n
p
n
p
n 1
1
1


Ejemplos
Ejemplos
Combinaciones de n sobre p 






 −
+








−
−
=








p
n
p
n
p
n 1
1
1
Orden de eficiencia:
Orden de eficiencia: Θ
Θ(
(np
np)
) 17
17

Ejemplos
Ejemplos
int
int combinaciones
combinaciones (
(int
int n,
n, int
int p)
p)
{
{
for
for (i=0; i=n; i++) {
(i=0; i=n; i++) {







 −
+








−
−
=








p
n
p
n
p
n 1
1
1
for
for (j=0; j=min(
(j=0; j=min(i,p
i,p);
); j++
j++) {
) {
if
if ((j==0) || (j==i))
((j==0) || (j==i))
c[i][j] = 1
c[i][j] = 1
else
else
c[i][j] = c[i
c[i][j] = c[i-
-1][j
1][j–
–1]+c[i
1]+c[i-
-1][j];
1][j];
}
}
}
}
return
return c[n][p];
c[n][p];
}
}
Θ(
(np
np) en tiempo,
) en tiempo, Θ
Θ(
(np
np) en espacio.
) en espacio.
18
18
Ejemplos
Ejemplos
int
int combinaciones
combinaciones (
(int
int n,
n, int
int p)
p)
{
{
b[0] = 1;
b[0] = 1;







 −
+








−
−
=








p
n
p
n
p
n 1
1
1
for
for (i=1; i=n; i++) {
(i=1; i=n; i++) {
b[i] = 1;
b[i] = 1;
for
for (j=i
(j=i–
–1; j0; j
1; j0; j--
--) {
) {
b[j] += b[j
b[j] += b[j –
– 1];
1];
}
}
}
}
return
return b[p];
b[p];
}
}
Θ(
(np
np) en tiempo,
) en tiempo, Θ
Θ(n) en espacio.
(n) en espacio.
19
19

Devolver el cambio…
Existen casos para los que no se puede aplicar el
Existen casos para los que no se puede aplicar el
algoritmo
algoritmo greedy
greedy (por ejemplo, devolver 8 peniques
(por ejemplo, devolver 8 peniques
con monedas de 6, 4 y 1 penique).
con monedas de 6, 4 y 1 penique).
Definición recursiva de la solución
Cálculo de la solución con programación dinámica:
Cálculo de la solución con programación dinámica:

Orden de eficiencia proporcional al tamaño de la tabla,
Orden de eficiencia proporcional al tamaño de la tabla,
O(
O(Cn
Cn), donde n es el número de monedas distintas.
), donde n es el número de monedas distintas.
20
20



−
+
= −
)
},
,...,
({
1
)
},
,...,
({
min
)
},
,...,
({
1
1
1
1
i
i
i
i
m
C
m
m
cambio
C
m
m
cambio
C
m
m
cambio



−
+
= −
)
},
,...,
({
1
)
},
,...,
({
min
)
},
,...,
({
1
1
1
1
i
i
i
i
m
C
m
m
cambio
C
m
m
cambio
C
m
m
cambio
m={1,4,6}, C=8
m={1,4,6}, C=8
Solución: 2 monedas, S={4,4}.
Solución: 2 monedas, S={4,4}.
21
21
0 1 2 3 4 5 6 7 8
{1} 0 1 2 3 4 5 6 7 8
{1,4} 0 1 2 3 1 2 3 4 2
{1,4,6} 0 1 2 3 1 2 1 2 2

Propiedad asociativa del producto de matrices:
Propiedad asociativa del producto de matrices:
Dadas las matrices A
Dadas las matrices A1
1 (10x100), A
(10x100), A2
2 (100x5) y A
(100x5) y A3
3 (5x50),
(5x50),

(A
(A1
1A
A2
2)A
)A3
3 implica 7500 multiplicaciones
implica 7500 multiplicaciones

A
A1
1(A
(A2
2A
A3
3) implica 75000 multiplicaciones
) implica 75000 multiplicaciones

A
A1
1(A
(A2
2A
A3
3) implica 75000 multiplicaciones
) implica 75000 multiplicaciones
“
“Parentizaciones
Parentizaciones” posibles:
” posibles:
22
22






−
=
=
∑
−
=
1
)
(
)
(
1
1
)
(
1
1
n
si
k
n
P
k
P
n
si
n
P
n
k








Ω 2
4
n
n
Si cada matriz
Si cada matriz A
Ak
k tiene un tamaño p
tiene un tamaño pk
k-
-1
1p
pk
k,
,
el número de multiplicaciones necesario será:
el número de multiplicaciones necesario será:
n
k p
p
p
n
k
m
k
m
n
m 0
)
,
1
(
)
,
1
(
)
,
1
( +
+
+
=
De forma general:
De forma general:
23
23
A1 x A2 x A3 x…x Ak Ak+1 x Ak+2 x … x An
x
j
k
i p
p
p
j
k
m
k
i
m
j
i
m 1
)
,
1
(
)
,
(
)
,
( −
+
+
+
=

Matriz
Matriz A
Ak
k de tamaño p
de tamaño pk
k-
-1
1p
pk
k
Definición recursiva de la solución óptima:
:

Si i=j, entonces
Si i=j, entonces

Si
Si i
i≠j
≠j, entonces
, entonces
24
24
A1 x A2 x A3 x…x Ak Ak+1 x Ak+2 x … x An
x
{ }
j
k
i
j
k
i
p
p
p
j
k
m
k
i
m
j
i
m 1
)
,
1
(
)
,
(
min
)
,
( −

≤
+
+
+
=
0
)
,
( =
j
i
m
Implementación:
Implementación:

Tenemos n
Tenemos n2
2 subproblemas
subproblemas distintos m(
distintos m(i,j
i,j).
).

Para calcular m(
Para calcular m(i,j
i,j) necesitamos los valores
) necesitamos los valores

Para calcular m(
Para calcular m(i,j
i,j) necesitamos los valores
) necesitamos los valores
almacenados en la fila i y en la columna j
almacenados en la fila i y en la columna j

Para calcular cada valor necesitamos O(n),
Para calcular cada valor necesitamos O(n),
por lo que el algoritmo resultante es de orden O(n
por lo que el algoritmo resultante es de orden O(n3
3).
).
25
25
{ }
j
k
i
j
k
i
p
p
p
j
k
m
k
i
m
j
i
m 1
)
,
1
(
)
,
(
min
)
,
( −

≤
+
+
+
=

Implementación:
Implementación:
for
for (i=1; i=n; i++)
(i=1; i=n; i++)
m[
m[i,i
i,i] = 0;
] = 0;
for
for (s=2; s=n; l++)
(s=2; s=n; l++)
for
for (i=1; i=n
(i=1; i=n-
-s+1; i++) {
s+1; i++) {
for
for (i=1; i=n
(i=1; i=n-
-s+1; i++) {
s+1; i++) {
j = i+s
j = i+s-
-1;
1;
m[
m[i,j
i,j] = ∞;
] = ∞;
for
for (k=i; k=j
(k=i; k=j-
-1; k++) {
1; k++) {
q = m[
q = m[i,k
i,k] + m[k+1,j] + p[i
] + m[k+1,j] + p[i-
-1]*p[k]p[j]
1]*p[k]p[j]
if
if (q m[
(q m[i,j
i,j]) {
]) {
m[
m[i,j
i,j] = q;
] = q;
s[
s[i,j
i,j] = k;
] = k;
}
}
}
}
}
}
26
26
Implementación:
Implementación:
// Suponiendo que hemos calculado previamente s[
// Suponiendo que hemos calculado previamente s[i,j
i,j]…
]…
MultiplicaCadenaMatrices
MultiplicaCadenaMatrices (A, i, j)
(A, i, j)
{
{
{
{
if
if (ji) {
(ji) {
x =
x = MultplicaCadenaMatrices
MultplicaCadenaMatrices (A, i, s[
(A, i, s[i,j
i,j]);
]);
y =
y = MultplicaCadenaMatrices
MultplicaCadenaMatrices (A, s[
(A, s[i,j
i,j]+1, j);
]+1, j);
return
return MultiplicaMatrices
MultiplicaMatrices(x, y);
(x, y);
}
} else
else {
{
return
return A[i];
A[i];
}
}
}
}
27
27

Subsecuencia
Problema:
Problema:
Comparar dos cadenas y encontrar la
Comparar dos cadenas y encontrar la subsecuencia
subsecuencia
común de mayor longitud.
común de mayor longitud.
Ejemplo:
Ejemplo:
Cadenas:
Cadenas:
X = (A B C B D A B),
X = (A B C B D A B),
Y = (B D C A B A),
Y = (B D C A B A),
Subsecuencia
Subsecuencia común de mayor longitud:
común de mayor longitud:
LCS = (B C B A)
LCS = (B C B A)
X = ( A
X = ( A B
B C
C B
B D
D A
A B )
B )
Y = (
Y = ( B
B D
D C
C A
A B
B A
A )
) 28
28
Subsecuencia
Un algoritmo de fuerza bruta compararía cualquier
Un algoritmo de fuerza bruta compararía cualquier
subsecuencia
subsecuencia de X con los símbolos de Y:
de X con los símbolos de Y:
Si |X|=m, |Y|=n, entonces hay 2
Si |X|=m, |Y|=n, entonces hay 2m
m subsecuencias
subsecuencias de X
de X
que debemos comparar con Y (n comparaciones), por
lo que nuestro algoritmo sería de orden
lo que nuestro algoritmo sería de orden O(n2
O(n2m
m)
).
.
Sin embargo, LCS tiene subestructuras
Sin embargo, LCS tiene subestructuras optimales
optimales:
:
Si buscamos la LCS para pares de prefijos de X e Y,
podemos calcular la solución de nuestro problema…
29
29

Subsecuencia
X
Xi
i Prefijo de X de longitud i.
Prefijo de X de longitud i.
Y
Yj
j Prefijo de Y de longitud j.
Prefijo de Y de longitud j.
Y
Yj
j Prefijo de Y de longitud j.
Prefijo de Y de longitud j.
c(
c(i,j
i,j)
) Longitud de la LCS para X
Longitud de la LCS para Xi
i e
e Y
Yj
j.
.
La longitud de la
La longitud de la subsecuencia
subsecuencia de mayor longitud
de mayor longitud
(LCS) de X e Y será
(LCS) de X e Y será c(
c(m,n
m,n),
), con |X|=m, |Y|=n.
con |X|=m, |Y|=n. 30
30



−
−
=
+
−
−
=
caso
otro
en
j
i
c
j
i
c
j
y
i
x
si
j
i
c
j
i
c
)}
1
,
(
),
,
1
(
max{
]
[
]
[
1
)
1
,
1
(
)
,
(
Subsecuencia
Definición recursiva de la solución:

Caso base:
Caso base:
c(0,0) = 0
c(0,0) = 0 (
(Subcadena
Subcadena vacía)
vacía)
c(0,j) = c(i,0) = 0
c(0,j) = c(i,0) = 0 (LCS de la cadena vacía
(LCS de la cadena vacía
y cualquier otra cadena)

Cálculo recursivo:
Cálculo recursivo:

Primer caso (x[i]=y[j]=s): Se emparejan ambos
Primer caso (x[i]=y[j]=s): Se emparejan ambos
símbolos y la LCS aumenta de longitud:
símbolos y la LCS aumenta de longitud:
LCS(
LCS(X
Xi
i,Y
,Yj
j)= LCS(X
)= LCS(Xi
i-
-1
1,Y
,Yj
j-
-1
1)+{s}.
)+{s}.

Segundo caso (x[i]≠y[j]): No se pueden emparejar
Segundo caso (x[i]≠y[j]): No se pueden emparejar
los símbolos x[i] e y[j], por lo que LCS(
los símbolos x[i] e y[j], por lo que LCS(X
Xi
i,Y
,Yj
j) será
) será
la mejor entre LCS(X
la mejor entre LCS(Xi
i-
-1
1,Y
,Yj
j) y LCS(X
) y LCS(Xi
i,Y
,Yj
j-
-1
1).
). 31
31

Subsecuencia
Implementación iterativa del algoritmo:
Implementación iterativa del algoritmo:
int[][] LCS (X, Y)
{
for (i=0; i=X.length; i++) c[i][0]=0; // Y0
for (j=1; j=T.length; j++) c[0][j]=0; // X
for (j=1; j=T.length; j++) c[0][j]=0; // X0
for (i=1; i=X.length; i++) // Xi
for (j=1; j=Y.length; j++) // Yj
if ( X[i] == Y[j] )
c[i][j] = c[i-1][j-1] + 1;
else
c[i][j] = max ( c[i-1][j], c[i][j-1] );
return c;
} 32
32
Subsecuencia
Ejemplo:
Ejemplo:
X = (A B C B),
X = (A B C B),
Y = (B D C A B),
Y = (B D C A B),
Yj B D C A B
0 1 2 3 4 5
Xi 0 0 0 0 0 0 0
A 1 0
for (i=0; i=X.length; i++) c[i][0]=0; // Y0
for (j=1; j=T.length; j++) c[0][j]=0; // X0
33
33
B 2 0
C 3 0
B 4 0

Subsecuencia
Ejemplo:
Ejemplo:
X = (
X = (A
A B C B),
B C B),
Y = (
Y = (B D C
B D C A B),
A B),
Yj B D C A B
0 1 2 3 4 5
Xi 0 0 0 0 0 0 0
A 1 0 0 0 0
if ( X[i] == Y[j] )
c[i][j] = c[i-1][j-1] + 1;
else
c[i][j] = max ( c[i-1][j], c[i][j-1] ); 34
34
B 2 0
C 3 0
B 4 0
Subsecuencia
Ejemplo:
Ejemplo:
X = (
X = (A
A B C B),
B C B),
Y = (
Y = (B D C
B D C A
A B),
B),
Yj B D C A B
0 1 2 3 4 5
Xi 0 0 0 0 0 0 0
A 1 0 0 0 0 1
if ( X[i] == Y[j] )
c[i][j] = c[i-1][j-1] + 1;
else
c[i][j] = max ( c[i-1][j], c[i][j-1] ); 35
35
B 2 0
C 3 0
B 4 0

Subsecuencia
Ejemplo:
Ejemplo:
X = (
X = (A
A B C B),
B C B),
Y = (
Y = (B D C A
B D C A B
B),
),
Yj B D C A B
0 1 2 3 4 5
Xi 0 0 0 0 0 0 0
A 1 0 0 0 0 1 1
if ( X[i] == Y[j] )
c[i][j] = c[i-1][j-1] + 1;
else
c[i][j] = max ( c[i-1][j], c[i][j-1] ); 36
36
B 2 0
C 3 0
B 4 0
Subsecuencia
Ejemplo:
Ejemplo:
X = (A B C B),
X = (A B C B),
Y = (B D C A B),
Y = (B D C A B),
LCS = (B C B)
LCS = (B C B)
Yj B D C A B
0 1 2 3 4 5
Xi 0 0 0 0 0 0 0
A 1 0 0 0 0 1 1
LCS = (B C B)
LCS = (B C B)
X = ( A
X = ( A B
B C
C B
B )
)
Y = (
Y = ( B
B D
D C
C A
A B
B )
)
N
NOTA
OTA:
:
A partir del valor c[i][j] podemos determinar cómo
A partir del valor c[i][j] podemos determinar cómo
se calculó éste y encontrar la LCS hacia atrás…
se calculó éste y encontrar la LCS hacia atrás… 37
37
B 2 0 1 1 1 1 2
C 3 0 1 1 2 2 2
B 4 0 1 1 2 2 3

Enunciado del problema
Enunciado del problema
Dado un conjunto C de n tareas o actividades, con
Dado un conjunto C de n tareas o actividades, con
s
si
i = tiempo de comienzo de la actividad i
= tiempo de comienzo de la actividad i
s
si
i = tiempo de comienzo de la actividad i
= tiempo de comienzo de la actividad i
f
fi
i = tiempo de finalización de la actividad i
= tiempo de finalización de la actividad i
v
vi
i = valor (o peso) de la actividad i
= valor (o peso) de la actividad i
encontrar el subconjunto S de actividades compatibles
encontrar el subconjunto S de actividades compatibles
de peso máximo (esto es, un conjunto de actividades
de peso máximo (esto es, un conjunto de actividades
que no se solapen en el tiempo y que, además, nos
que no se solapen en el tiempo y que, además, nos
proporcione un valor máximo).
proporcione un valor máximo). 38
38
Recordatorio
Recordatorio
Existe un algoritmo
Existe un algoritmo greedy
greedy para este problema cuando
para este problema cuando
todas las actividades tienen el mismo valor (elegir las
todas las actividades tienen el mismo valor (elegir las
actividades en orden creciente de hora de finalización).
Sin embargo, el algoritmo
Sin embargo, el algoritmo greedy
greedy no funciona en general:
no funciona en general:
39
39
valor = 999
valor = 1
b
a

Observación
Observación
Si, como en el algoritmo
Si, como en el algoritmo greedy
greedy, ordenamos las
, ordenamos las
actividades por su hora de finalización…
actividades por su hora de finalización…
1
40
40
Tiempo
3
2
6
5
7
4
8
Observación
Observación
… podemos definir p(j) como el mayor índice ij
… podemos definir p(j) como el mayor índice ij
tal que la actividad i es compatible con la actividad j
tal que la actividad i es compatible con la actividad j
p(1)=0
41
41
Tiempo
p(3)=0
p(2)=0
p(6)=2
p(5)=0
p(7)=3
p(4)=1
p(8)=5





−
+
=
=
0
)}
1
(
)),
(
(
)
(
max{
0
0
)
(
j
si
j
OPT
j
p
OPT
j
v
j
si
j
OPT

Caso 1: Se elige la actividad j.
Caso 1: Se elige la actividad j.

No se pueden escoger actividades incompatibles p(j).
No se pueden escoger actividades incompatibles p(j).

La solución incluirá la solución óptima para p(j).
La solución incluirá la solución óptima para p(j).

Caso 2: No se elige la actividad j.
Caso 2: No se elige la actividad j.

La solución coincidirá con la solución óptima
La solución coincidirá con la solución óptima
para las primeras (j
para las primeras (j-
-1) actividades
1) actividades.
. 42
42
Implementación iterativa del algoritmo
Implementación iterativa del algoritmo
SelecciónActividadesConPesos
SelecciónActividadesConPesos (C: actividades): S
(C: actividades): S
{
{
Ordenar C según tiempo de finalización;
Ordenar C según tiempo de finalización; // O(n log n)
// O(n log n)
Calcular p[1]..p[n];
Calcular p[1]..p[n]; // O(n log n)
// O(n log n)
Calcular p[1]..p[n];
Calcular p[1]..p[n]; // O(n log n)
// O(n log n)
mejor[0] = 0;
mejor[0] = 0; // O(1)
// O(1)
for
for (i=1; i=n, i++)
(i=1; i=n, i++) // O(n)
// O(n)
mejor[i] =
mejor[i] = max
max ( valor[i]+mejor[p[i]],
( valor[i]+mejor[p[i]],
mejor[i
mejor[i-
-1] );
1] );
return
return Solución(mejor);
Solución(mejor); // O(n)
// O(n)
}
}
43
43

El problema de la mochila 0/1
Tenemos un conjunto S de n objetos, en el que cada
Tenemos un conjunto S de n objetos, en el que cada
objeto i tiene un beneficio
objeto i tiene un beneficio b
bi
i y un peso
y un peso w
wi
i positivos.
positivos.
Objetivo: Seleccionar
los elementos que nos
los elementos que nos
garantizan un beneficio
garantizan un beneficio
máximo pero
máximo pero pero
pero con
con
un peso global menor
un peso global menor
o igual que W.
o igual que W.
44
44
Dado el conjunto S de n objetos,
Dado el conjunto S de n objetos,
sea
sea S
Sk
k el conjunto de los k primeros objetos (de 1 a k):
el conjunto de los k primeros objetos (de 1 a k):
Podemos definir
Podemos definir B(
B(k,w
k,w)
) como la ganancia de la mejor
como la ganancia de la mejor
solución obtenida a partir de los elementos de
solución obtenida a partir de los elementos de S
Sk
k para
para
solución obtenida a partir de los elementos de
solución obtenida a partir de los elementos de S
Sk
k para
para
una mochila de capacidad w.
una mochila de capacidad w.
Ahora bien, la mejor selección de elementos del
Ahora bien, la mejor selección de elementos del
conjunto
conjunto S
Sk
k para una mochila de tamaño w se puede
para una mochila de tamaño w se puede
definir en función de selecciones de elementos de S
definir en función de selecciones de elementos de Sk
k-
-1
1
para mochilas de menor capacidad…
para mochilas de menor capacidad…
45
45

¿Cómo calculamos B(
¿Cómo calculamos B(k,w
k,w)?
)?
O bien la mejor opción para
O bien la mejor opción para S
Sk
k coincide con la mejor
coincide con la mejor
selección de elementos de S
selección de elementos de Sk
k-
-1
1 con peso máximo w
con peso máximo w
(el beneficio máximo para
(el beneficio máximo para S
Sk
k coincide con el de S
coincide con el de Sk
k-
-1
1),
),
(el beneficio máximo para
(el beneficio máximo para S
Sk
k coincide con el de S
coincide con el de Sk
k-
-1
1),
),
o bien es es el resultado de añadir el objeto k a la mejor
o bien es es el resultado de añadir el objeto k a la mejor
selección de elementos de S
selección de elementos de Sk
k-
-1
1 con peso máximo
con peso máximo
w−
w−w
wk
k (el beneficio para
(el beneficio para S
Sk
k será el beneficio que se
será el beneficio que se
obtenía en S
obtenía en Sk
k-
-1
1 para una mochila de capacidad w−
para una mochila de capacidad w−w
wk
k
más el beneficio
más el beneficio b
bk
k asociado al objeto k).
asociado al objeto k).
46
46
Definición recursiva de B(
Definición recursiva de B(k,w
k,w):
):



=
+
−
−
=
−
=
1
)
,
1
(
0
)
,
1
(
)
,
(
k
k
k
k
x
si
b
w
w
k
B
x
si
w
k
B
w
k
B
Para resolver el problema de la mochila nos
Para resolver el problema de la mochila nos
quedaremos con el máximo de ambos valores:
quedaremos con el máximo de ambos valores:
47
47
}
)
,
1
(
),
,
1
(
max{
)
,
( k
k b
w
w
k
B
w
k
B
w
k
B +
−
−
−
=

Cálculo ascendente de B(
Cálculo ascendente de B(k,w
k,w)
)
usando una matriz B de tamaño (n+1) x (W+1):
usando una matriz B de tamaño (n+1) x (W+1):
int
int[][]
[][] knapsack
knapsack (W, w[1..n], b[1..n])
(W, w[1..n], b[1..n])
{
{
for
for (p=0; p=W; p++)
(p=0; p=W; p++)
for
for (p=0; p=W; p++)
(p=0; p=W; p++)
B[0][p]=0;
B[0][p]=0;
for
for (k=1; k=n; k++) {
(k=1; k=n; k++) {
for
for (p=0; pw[k]; p++)
(p=0; pw[k]; p++)
B[k][p] = B[k
B[k][p] = B[k-
-1][p];
1][p];
for
for (p=w[k]; p=W; w++)
(p=w[k]; p=W; w++)
B[k][p] =
B[k][p] = max
max ( B[k
( B[k-
-1][p−w[k]]+b[k], B[k
1][p−w[k]]+b[k], B[k-
-1][p] );
1][p] );
}
}
return
return B;
B;
}
}
48
48
¿Cómo calculamos la solución óptima a partir de B(
¿Cómo calculamos la solución óptima a partir de B(k,w
k,w)?
)?
Calculamos la solución para B[k][w]
Calculamos la solución para B[k][w]
utilizando el siguiente algoritmo:
utilizando el siguiente algoritmo:
Si B[k][w] == B[k
Si B[k][w] == B[k-
-1][w],
1][w],
Si B[k][w] == B[k
Si B[k][w] == B[k-
-1][w],
1][w],
entonces el objeto k no se selecciona y se seleccionan
entonces el objeto k no se selecciona y se seleccionan
los objetos correspondientes a la solución óptima para
los objetos correspondientes a la solución óptima para
k
k-
-1 objetos y una mochila de capacidad w:
1 objetos y una mochila de capacidad w:
la solución para B[k
la solución para B[k-
-1][w].
1][w].
Si B[k][w] != B[k
Si B[k][w] != B[k-
-1][w],
1][w],
se selecciona el objeto k
se selecciona el objeto k
y los objetos correspondientes a la solución óptima
y los objetos correspondientes a la solución óptima
para k
para k-
-1 objetos y una mochila de capacidad w
1 objetos y una mochila de capacidad w-
-w[k]:
w[k]:
la solución para B[k
la solución para B[k-
-1][w
1][w-
-w[k]].
w[k]].
49
49

Eficiencia del algoritmo
Eficiencia del algoritmo
Tiempo de ejecución:
Tiempo de ejecución: Θ
Θ
Θ
Θ(n W)
“Pseudopolinómico” (no es polinómico sobre el tamaño
de la entrada; esto es, sobre el número de objetos).
de la entrada; esto es, sobre el número de objetos).
El problema de la mochila es NP.
NOTA: Existe un algoritmo polinómico de
orden O(n2v*) que proporciona una solución
aproximada al 0.01% del óptimo [Kleinberg
Tardos, sección 11.8: “Arbitrarily Good
Approximations: The Knapsack Problem”].
50
50
Ejemplo
Ejemplo
Mochila de tamaño
Mochila de tamaño W=11
W=11
Número de objetos
Número de objetos n=5
n=5
Solución óptima
Solución óptima {3,4}
{3,4}
1
Valor
18
22
28
1
Peso
5
6
6 2
7
Objeto
1
3
4
5
2
51
51
28 7
5
φ
{ 1, 2 }
{ 1, 2, 3 }
{ 1, 2, 3, 4 }
{ 1 }
{ 1, 2, 3, 4, 5 }
0
0
0
0
0
0
0
1
0
1
1
1
1
1
2
0
6
6
6
1
6
3
0
7
7
7
1
7
4
0
7
7
7
1
7
5
0
7
18
18
1
18
6
0
7
19
22
1
22
7
0
7
24
24
1
28
8
0
7
25
28
1
29
9
0
7
25
29
1
34
10
0
7
25
29
1
35
11
0
7
25
40
1
40

Caminos mínimos: Algoritmo de Floyd
Problema:
Problema:
Calcular el camino más corto que une cada par de
Calcular el camino más corto que une cada par de
vértices de un grafo, considerando que no hay pesos
vértices de un grafo, considerando que no hay pesos
negativos.
negativos.
Posibles soluciones:
Posibles soluciones:

Por fuerza bruta (de orden exponencial).
Por fuerza bruta (de orden exponencial).

Aplicar el algoritmo de
Aplicar el algoritmo de Dijkstra
Dijkstra para cada vértice.
para cada vértice.

Algoritmo de Floyd (programación dinámica).
Algoritmo de Floyd (programación dinámica). 52
52
D
Dk
k(
(i,j
i,j)
): Camino más corto de i a j usando sólo los k
: Camino más corto de i a j usando sólo los k
primeros vértices del grafo como puntos intermedios.
primeros vértices del grafo como puntos intermedios.
Expresión recursiva:
Expresión recursiva:
Caso base:
Caso base:
53
53
)}
,
(
)
,
(
),
,
(
min{
)
,
( 1
1
1 j
k
D
k
i
D
j
i
D
j
i
D k
k
k
k −
−
− +
=
ij
c
j
i
D =
)
,
(
0

Algoritmo de Floyd (1962):
Algoritmo de Floyd (1962): Θ
Θ
Θ
Θ(V3)
for
for (i=0; in; i++)
(i=0; in; i++)
for
for (j=0; jn;
(j=0; jn; j++
j++)
)
D[i][j] = coste(
D[i][j] = coste(i,j
i,j);
);
for
for (k=0; kn; k++)
(k=0; kn; k++)
for
for (i=0; in; i++)
(i=0; in; i++)
for
for (j=0; jn;
(j=0; jn; j++
j++)
)
if
if (D[i][k] + D[k][j] D[i][j] )
(D[i][k] + D[k][j] D[i][j] )
D[i][j] = D[i][k] + D[k][j];
D[i][j] = D[i][k] + D[k][j];
54
54
)}
,
(
)
,
(
),
,
(
min{
)
,
( 1
1
1 j
k
D
k
i
D
j
i
D
j
i
D k
k
k
k −
−
− +
=
Caminos mínimos: Algoritmo de
Caminos mínimos: Algoritmo de Bellman
Bellman-
-Ford
Ford
Si sólo nos interesan los caminos mínimos desde un
Si sólo nos interesan los caminos mínimos desde un
vértice concreto del grafo G(V,E), podemos utilizar el
vértice concreto del grafo G(V,E), podemos utilizar el
algoritmo
algoritmo greedy
greedy de
de Dijkstra
Dijkstra, de orden
, de orden O(E log V)
O(E log V),
,
siempre y cuando tengamos
siempre y cuando tengamos pesos no negativos
pesos no negativos.
.
El algoritmo de
El algoritmo de Dijkstra
Dijkstra no funciona con pesos negativos:
no funciona con pesos negativos:
¡Ojo!
¡Ojo!
Tampoco podemos sumarle una constante a cada peso.
Tampoco podemos sumarle una constante a cada peso. 55
55
t
s
2
1
3
-6

Bellman-
-Ford
Ford
Si tenemos pesos negativos, podemos utilizar el
Si tenemos pesos negativos, podemos utilizar el
algoritmo de
algoritmo de Bellman
Bellman-
-Ford, basado en programación
Ford, basado en programación
dinámica y de orden
dinámica y de orden O(EV)
O(EV), siempre y cuando no
, siempre y cuando no
tengamos ciclos de peso negativo:
tengamos ciclos de peso negativo:
N
NOTA
OTA: Si un camino de s a t incluye un ciclo de peso negativo,
: Si un camino de s a t incluye un ciclo de peso negativo,
no existe un camino “más corto” de s a t (y, en cualquier caso,
no existe un camino “más corto” de s a t (y, en cualquier caso,
Bellman
Bellman-
-Ford tampoco encontraría el camino simple más corto).
Ford tampoco encontraría el camino simple más corto). 56
56





+
=
∞
=
−
∈
− caso
otro
en
}}
)
(
{
min
,
)
(
min{
0
i
si
)
(
1
)
,
(
1 vw
i
E
w
v
i
i c
v
D
w
D
w
D
Bellman-
-Ford
Ford
Algoritmo de
Algoritmo de Bellman
Bellman-
-Ford:
Ford: Θ
Θ
Θ
Θ(EV)
foreach
foreach v
v ∈
∈
∈
∈
∈
∈
∈
∈ V {
V {
D[v]
D[v] =
= ∞
∞
∞
∞
∞
∞
∞
∞;
;
predecesor
predecesor[v] = null;
[v] = null;
}
}
}
}
D[s] = 0;
D[s] = 0;
for
for (
(i
i=1;
=1; i
in;
n; i
i++) {
++) {
foreach
foreach (v, w)
(v, w) ∈
∈
∈
∈
∈
∈
∈
∈ E
E {
{
if
if (D[v] +
(D[v] + coste
coste(
(v,w
v,w) D[w]) {
) D[w]) {
D[w] = D[v] +
D[w] = D[v] + coste
coste(
(v,w
v,w);
);
predecesor
predecesor[w] = v;
[w] = v;
}
}
}
}
}
} 57
57

También conocida como distancia
También conocida como distancia Levenshtein
Levenshtein, mide
, mide
la diferencia entre dos cadenas s y t como el número
la diferencia entre dos cadenas s y t como el número
mínimo de operaciones de edición que hay que
mínimo de operaciones de edición que hay que
realizar para convertir una cadena en otra:
realizar para convertir una cadena en otra:
d(“data
d(“data mining
mining”, “data minino”) = 1
”, “data minino”) = 1
d(“efecto”, “defecto”) = 1
d(“efecto”, “defecto”) = 1
d(“poda”, “boda”) = 1
d(“poda”, “boda”) = 1
d(“
d(“night”,”natch
night”,”natch”) = d(“
”) = d(“natch”,”noche
natch”,”noche”) = 3
”) = 3
Aplicaciones:
Aplicaciones: Correctores ortográficos, reconocimiento
Correctores ortográficos, reconocimiento
de voz, detección de plagios, análisis de ADN…
de voz, detección de plagios, análisis de ADN…
Para datos binarios:
Para datos binarios: Distancia de
Distancia de Hamming
Hamming.
.
58
58



≠
−
−
−
−
+
=
−
−
=
]
[
]
[
)}
1
,
1
(
),
1
,
(
),
,
1
(
min{
1
]
[
]
[
)
1
,
1
(
)
,
(
j
t
i
s
si
j
i
d
j
i
d
j
i
d
j
t
i
s
si
j
i
d
j
i
d
CASOS
CASOS

Mismo carácter:
Mismo carácter: d(i
d(i-
-1,j
1,j-
-1)
1)

Inserción:
Inserción: 1 + d(i
1 + d(i-
-1,j)
1,j)

Borrado:
Borrado: 1 + d(i,j
1 + d(i,j-
-1)
1)

Modificación:
Modificación: 1 + d(i
1 + d(i-
-1,j
1,j-
-1)
1)
59
59

int
int LevenshteinDistance
LevenshteinDistance (
(string
string s[1..m],
s[1..m], string
string t[1..n])
t[1..n])
{
{
for
for (i=0; i=m; i++) d[i,0]=i;
(i=0; i=m; i++) d[i,0]=i;
for
for (j=0; j=n;
(j=0; j=n; j++
j++) d[0,j]=j;
) d[0,j]=j;
for
for (j=1; j=n;
(j=1; j=n; j++
j++)
)
for
for (i=1; i=m; i++)
(i=1; i=m; i++)
for
for (i=1; i=m; i++)
(i=1; i=m; i++)
if
if (s[i]==t[j])
(s[i]==t[j])
d[
d[i,j
i,j] = d[i
] = d[i-
-1, j
1, j-
-1]
1]
else
else
d[
d[i,j
i,j] = 1+ min(d[i
] = 1+ min(d[i-
-1,j],d[i,j
1,j],d[i,j-
-1],d[i
1],d[i-
-1,j
1,j-
-1]);
1]);
return
return d[
d[m,n
m,n];
];
}
}
60
60



≠
−
−
−
−
+
=
−
−
=
]
[
]
[
)}
1
,
1
(
),
1
,
(
),
,
1
(
min{
1
]
[
]
[
)
1
,
1
(
)
,
(
j
t
i
s
si
j
i
d
j
i
d
j
i
d
j
t
i
s
si
j
i
d
j
i
d
Aplicaciones
Aplicaciones

Distancia entre dos series temporales: O(n
Distancia entre dos series temporales: O(n2
2)
)
DTW [
DTW [Dynamic
Dynamic Time
Time Warping
Warping]
]

Análisis sintáctico: O(n
Análisis sintáctico: O(n3
3)
)

Algoritmo CKY [
Algoritmo CKY [Cocke
Cocke-
-Kasami
Kasami-
-Younger
Younger]
]

Algoritmo de
Algoritmo de Earley
Earley

Algoritmo de
Algoritmo de Earley
Earley

Algoritmo de
Algoritmo de Viterbi
Viterbi:
: HMMs
HMMs [
[Hidden
Hidden Markov
Markov Models
Models]
]

Decodificación de señales (p.ej.
Decodificación de señales (p.ej. modems
modems, GSM,
, GSM, wi
wi-
-fi)
fi)

Procesamiento del lenguaje natural
Procesamiento del lenguaje natural

Bioinformática
Bioinformática

Optimización de consultas en bases de datos relacionales
Optimización de consultas en bases de datos relacionales

Comparación de ficheros con
Comparación de ficheros con diff
diff

…
… 61
61

6 dynamic programming

Más contenido relacionado

Similar a 6 dynamic programming (20)

Último (20)

6 dynamic programming