Soluções para a lição de casa oito CSE 101

1. Problema do livro didático 6.1.

Subproblema: Seja S(j) a soma da subsequência contígua de soma máxima que termina exatamente em j (mas é
possivelmente de comprimento zero). Queremos max j S(j ).
Formulação recursiva: A subsequência que define S(j) ou (i) tem comprimento zero, ou (ii) consiste na melhor
subsequência terminando em umj-1, seguido pelo elemento aj. Portanto

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

Para consistência S(0) = 0.

Algoritmo:

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

Tempo de duração: Loop único: O(n).

2. Problema do livro didático 6.2.

Subproblema: Seja T (j) a penalidade mínima incorrida até a localizaçãode j , supondo que você pare por aí. Queremos T
(n).
Formulação recursiva: Suponhamos que paremos em umj . A parada anterior é some a i,i < j (ou talvez aj é a primeira
parada). Vamos tentar todas as possibilidades para um : i

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

i
)2

0≤i<j

onde por conveniência definimos T (0) = 0 e a 0 = . 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-a i) } )2

retorno T(n)

Tempo de duração: Dois laços, O(n ). 2

3. Problema do livro didático 6.7.

Subproblema: Definir T (i, j) como sendo o comprimento da maior subsequência palindrômica de x[i . . . j]. Queremos T(1,
n).
Formulação recursiva: Na computação T (i, j), a primeira questão é se x[i] = x[j]. Se assim for, podemos combiná-los e
depois recursar para dentro, para T (i + 1, j - 1). Se não, pelo menos um deles não está no palíndromo.

(1 se i = j
T(i,j) = 2 + T(i + 1,j - 1) se eu < j e x[i] = x[j]
[ max{T (i + 1,j), T (i,j — 1) } caso contrário

Para consistência defina T (i, i - 1) = 0 para todos os i.

Algoritmo: Calcular o T(i, j) em ordem crescente de comprimento 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: (duração do intervalo)
para i = 1 a n - d:
j=i+d
se x[i] = x[j]:
T[i,j]=2+T[i+1,j-1]
mais:
T[i,j] =max{T[i+1,j],T[i,j-1]} retornar T[1, n]

Tempo de duração: Existem subproblemas O(n 2) e cada um leva O(1) tempo para computar, então o tempo total de
execução é O(n ). 2

4. Problema do livro didático 6.17.

Subproblema: Para qualquer inteiro 0 ≤ u ≤ v, defina T (u) como verdadeiro se for possível fazer alterações para você
usando as moedas dadas x1 , x2 , . . , xn . A resposta que queremos é T (v).
Formulação recursiva: Observe que

T (u) é verdadeiro se e somente se T (u - x i) é verdadeiro para alguns . i

Para consistência, defina T (0) como true.

Algoritmo:

T [0] = verdadeiro
para você = 1 a v:
T [u] = falso
para i = 1 a n:
se você ≥ x i e T [u - x ]: T [u] = verdadeiro
i

Tempo de duração: A tabela tem tamanho v e cada entrada leva O(n) tempo para ser preenchida; portanto, o tempo total de
execução é O(nv).

5. Número de caminhos em um DAG.

Subproblema: Suponha que G seja um grafo acíclico direcionado. Para qualquer nó v no gráfico, defina numpaths[v] como o
número de caminhos de s a v. A quantidade que queremos é numpaths[t].
Formulação recursiva: Escolha (u, qualquer nó v 6= s no gráfico. Qualquer caminho de s a v termina em uma aresta
v) ∈ E . Assim:
numpaths[v] = numpaths[u].
u:(u,v)∈E

E, claro, numpaths[s] = 1.
Algoritmo: Podemos preencher a matriz considerando os nós em ordem topológica:

Encontre uma ordem topológica de G para todos os V ∈ V :

numpaths[v] = 0
numpaths[s] = 1
para todos u ∈ V , por ordem topológica:
para todos (u, v) ∈ E :
numpaths[v] = numpaths[v] + numpaths[u] retornar numpaths[t]

Tempo de duração: O tempo total de execução é O(V + E), linear.

6. Problema do livro didático 6.21.

Subproblema: Enraizar a árvore em qualquer nó r. Para cada u ∈ V , defina

T(u) = tamanho da menor cobertura de vértices da subárvore enraizada em u.

Queremos T (r).

2
 Formulação recursiva: Ao descobrir T (u), a questão mais imediata é se u está na cobertura de vértices. Se não, então seus
filhos devem estar na cobertura do vértice. Que C(u) seja o conjunto de seus filhos, e que G(u) seja seu neto. Então

T(u) = min
।)
T(u)=min
|C(u)|+P z∈G(u)T(z)

onde |C (u)| é o número de filhos do nó u. O primeiro caso inclui u na cobertura do vértice; o segundo caso, não.
Algoritmo:

Escolha qualquer nó raiz r

dist[·] = BFS(árvore, r)

para todos os nós u, em ordem decrescente dist:

51 = 1 (opção 1: incluir u na cobertura dos vértices)
para todos (u, w) ∈ E tal que dist[w] = dist[u] + 1: (ou seja, w = filho de você):
S 1 = S1 + T [w]
52 = 0 (opção 2: não incluir u na cobertura de vértices)
para todos (u, w) ∈ E tal que dist[w] = dist[u] + 1: (ou seja, w = filho de você):
S 2 = S2 + 1
para todos (w, z) ∈ E tal que dist[z] = dist[w] + 1: (ou seja, z = neto de você):
S 2 = S2 + T [z]
T[u] = min{S1,S 2}
retorno T [r]

Tempo de duração: O trabalho realizado em cada nó é proporcional ao seu número de netos, |G(u)|. Desde u |G(u)| ≤ |
V | (cada nó tem no máximo um avô), o trabalho geral feito é linear.

7. Problema do livro didático 6.19.

Subproblema: Para quaisquer inteiros 0 ≤ u ≤ v e 0 ≤ j ≤ k, defina T (u, j) como verdadeiro se for possível fazer alterações
para você usando no máximo j moedas com denominações escolhidas de x1 , x2 , . . , xn. A resposta que queremos é T (v, k).
Formulação recursiva: Observe que

T(u, j) é verdadeiro se e somente se (u = 0 ou (T(u - x i,j - 1) é verdadeiro para alguns i)).

Para consistência, defina T (0, j) como true para todos j e T (u, 0) como false para você > 0.
Algoritmo:

para j = 0 a k:
T [0, j] = verdadeiro
para você = 1 a v:
T [u, 0] = falso
para j = 1 a k:
para você = 1 a v:
T [u, j] = falso
para i = 1 a n:
se você ≥ x i e T [u - xi, j - 1]: T [u, j] = verdadeiro
retorno T [v, k]

Tempo de duração: A tabela tem tamanho k × v e cada entrada leva O(n) tempo para preencher; portanto, o tempo total de
execução é O (nkv).