Soluciones a los octavos deberes CSE 101

1. Problema 6.1 del libro de texto.

Subproblema: Sea S(j) la suma de la subsecuencia contigua de suma máxima que termina exactamente en aj ( pero que
posiblemente tenga longitud cero). Queremos maxjS (j).
Formulación recursiva: La subsecuencia que define S(j) o bien (i) tiene longitud cero, o bien (ii) está formada por la mejor
subsecuencia que termina enaj-1, seguida del elementoaj. Por lo tanto,

S(j) = max{0,aj + S(j - 1)}.

Por coherencia, S(0) = 0.

Algoritmo:

S[0] = 0
para j = 1 a n:
S[j] = max(0,aj + S[j - 1])
return maxjS [j]

Duración: Bucle simple: O(n).

2. Problema 6.2 del libro de texto.

Subproblema: Sea T (j) la penalización mínima incurrida hasta la ubicaciónaj , suponiendo que se detiene allí. Queremos T
(n).
Formulación recursiva: Supongamos que nos detenemos enaj . La parada anterior es alguna ai, i < j (o tal vezaj es la primera
parada). Probemos todas las posibilidades para : ai

T(j) = min T(i) + (200 - (aj - ) ,

ai
)2

0≤i<j

donde por comodidad fijamos T (0) = 0 y a0 = 0.

Algoritmo:

para j = 1 a n:
T(j)=(200-aj
)2

para i = 1 a j - 1:
T(j)=min{T(j),T(i)+(200-(aj-ai))2}
devolver T(n)

Tiempo de ejecución: Dos bucles, O( ). n2

3. Problema 6.7 del libro de texto.

Subproblema: Definir T (i, j) como la longitud de la subsecuencia palindrómica más larga de x[i . . . j]. Queremos T(1, n).
Formulación recursiva: Al calcular T (i, j), la primera pregunta es si x[i] = x[j]. Si es así, podemos emparejarlos y luego
recurrir hacia dentro, hasta T (i + 1, j - 1). Si no es así, entonces al menos uno de ellos no está en el palíndromo.

(1 si i = j
T(i,j) = 2 + T(i + 1,j - 1) si i < j y x[i] = x[j]
[ max{T (i + 1,j),T (i,j - 1)} en caso contrario

Por coherencia, T(i, i - 1) = 0 para todo i.

Algoritmo: Calcula el T(i, j) en orden creciente de longitud de intervalo |j - i|.

1
 para i = 2 a n + 1:
T[i, i - 1] = 0 para i = 1 a n:
T[i,i]=1
para d = 1 a n - 1: (longitud del intervalo)
para i = 1 a n - d:
j=i+d
si x[i] = x[j]:
T[i,j]=2+T[i+1,j-1]
si no:
T[i,j] =max{T[i+1,j],T[i,j-1]} return T[1, n]

Tiempo de ejecución: Hay O( ) subproblemas y cada uno tarda O(1) tiempo en calcularse, por lo que el tiempo total de
n2

ejecución es O( ).
n2

4. Problema 6.17 del libro de texto.

Subproblema: Para cualquier entero 0 ≤ u ≤ v, defina T (u) como verdadero si es posible realizar el cambio de u utilizando las
monedas dadas x1, x2, . . . , xn. La respuesta que queremos es T (v).
Formulación recursiva: Obsérvese que

T (u) es verdadera si y sólo si T (u - ) es verdadera para algún i.

xi

Por coherencia, se establece T (0) como verdadero.

Algoritmo:

T [0] = verdadero
para u = 1 a v:
T [u] = falso
para i = 1 a n:
si u ≥ y T [u - ]: T [u] = verdadero
xi xi

Tiempo de ejecución: La tabla tiene un tamaño v y cada entrada tarda O(n) en llenarse; por tanto, el tiempo total de
ejecución es O(nv).

5. Número de rutas en un DAG.

Subproblema: Supongamos que G es un grafo acíclico dirigido. Para cualquier nodo v del grafo, define numpaths[v] como el
número de caminos de s a v. La cantidad que queremos es numpaths[t].
Formulación recursiva: Elige (u, v ) cualquier nodo v 6= s del grafo. Cualquier camino de s a v termina en una arista
∈ E . Así:
numpaths[v] = numpaths[u].
u:(u,v)∈E

Y, por supuesto, numpaths[s] = 1.

Algoritmo: Podemos rellenar la matriz considerando los nodos en orden topológico:

Encontrar una ordenación topológica de G para todo v ∈ V :

numpaths[v] = 0
numpaths[s] = 1
para todo u ∈ V , en orden topológico:
para todo (u, v) ∈ E :
recorridos[v] = recorridos[v] + recorridos[u] return recorridos[t]

Tiempo de ejecución: El tiempo total de ejecución es O(V + E), lineal.

6. Problema 6.21 del libro de texto.

Subproblema: Enraizar el árbol en cualquier nodo r. Para cada u ∈ V , defina

T(u) = tamaño de la cobertura de vértices más pequeña del subárbol enraizado en u.

Queremos T (r).

2
 Formulación recursiva: Al averiguar T (u), la pregunta más inmediata es si u está en la cubierta de vértices. Si no, sus hijos
deben estar en la cubierta de vértices. Sea C(u) el conjunto de los hijos de u, y G(u) sus nietos. Entonces

T(u) = min
।)
T(u)=mín
|C(u)|+Pz∈G(u)T(z)

donde |C (u)| es el número de hijos del nodo u. El primer caso incluye u en la cubierta de vértices; el segundo, no.
Algoritmo:

Elija cualquier nodo raíz r

dist[-] = BFS(árbol, r)

para todos los nodos u, en orden de dist. decreciente:

51 = 1 (opción 1: incluir u en la cubierta de vértices)
para todo (u, w) ∈ E tal que dist[w] = dist[u] + 1: (es decir, w = hijo de u):
S1= S1+ T [w]
52 = 0 (opción 2: no incluir u en la cubierta de vértices)
para todo (u, w) ∈ E tal que dist[w] = dist[u] + 1: (es decir, w = hijo de u):
S2= S2+ 1
para todo (w, z) ∈ E tal que dist[z] = dist[w] + 1: (es decir, z = nieto de u):
S2= S2+ T [z]
T[u] = min{S1,S2}
devolver T [r]

Tiempo de ejecución: El trabajo realizado en cada nodo es proporcional a su número de nietos, |G(u)|. Desde u |G(u)| ≤ |
V | (cada nodo tiene como máximo un abuelo), el trabajo total realizado es lineal.

7. Problema 6.19 del libro de texto.

Subproblema: Para cualesquiera enteros 0 ≤ u ≤ v y 0 ≤ j ≤ k, defina T (u, j) como verdadero si es posible hacer el cambio de
u utilizando como máximo j monedas con denominaciones elegidas entre x1 , x2, . . . . , xn. La respuesta que queremos es T
(v, k).
Formulación recursiva: Obsérvese que

T(u, j) es verdadera si y sólo si (o u = 0 o (T(u - xi,j - 1) es verdadera para algún i)).

Por coherencia, establezca T (0, j) como verdadero para todo j y T (u, 0) como falso para u > 0.
Algoritmo:

para j = 0 a k:
T [0, j] = verdadero
para u = 1 a v:
T [u, 0] = falso
para j = 1 a k:
para u = 1 a v:
T [u, j] = falso
para i = 1 a n:
si u ≥ xiy T [u - xi, j - 1]: T [u, j] = verdadero
return T [v, k]

Tiempo de ejecución: La tabla tiene un tamaño k × v y cada entrada tarda O(n) en llenarse; por lo tanto, el tiempo total de
ejecución es O (nkv).