Soluții pentru temele opt CSE 101

1. Problema manualului 6.1.

Subproblemă: Fie S(j) suma subsecvenței contigue cu sumă maximă care se termină exact la un j (dar este posibil de
lungime zero). Vrem max j S(j ).
Formulare recursivă: Subsecvența care definește S(j) fie (i) are lungimea zero, fie (ii) constă din cea mai bună subsecvență
care se termină la unj-1, urmată de elementul aj. Deci

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

Pentru consecvență S(0) = 0.

Algoritm:

S[0] = 0
pentru j = 1 la n:
S[j] = max(0, a j + S[j - 1])
returnare max j S[j ]

Durata spectacolului: Buclă unică: O(n).

2. Problema manualului 6.2.

Subproblemă: Fie T (j) pedeapsa minimă suportată până la locația aj , presupunând că vă opriți aici. Vrem T (n).
Formulare recursivă: Să presupunem că ne oprim la unj . Oprirea anterioară este uni, i < j (sau poate unj este prima oprire).
Să încercăm toate posibilitățile pentru un : i

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

i
2

0≤i<j

unde pentru comoditate setăm T (0) = 0 și a 0 = . 0

Algoritm:

pentru j = 1 la n:
T(j)=(200-aj) 2

pentru i = 1 la j - 1:
T(j)=min{T(j),T(i)+(200-(aj-a i)) }
2

returnează T(n)

Durata spectacolului: Două bucle, O( ). n2

3. Problema manualului 6.7.

Subproblemă: Definiți T (i, j) ca fiind lungimea celei mai lungi subsecvențe palindromice a lui x[i . . . . j]. Vrem T(1, n).
Formulare recursivă: În calculul T (i, j), prima întrebare este dacă x[i] = x[j]. Dacă da, le putem potrivi și apoi recursa spre
interior, la T (i + 1, j - 1). Dacă nu, atunci cel puțin unul dintre ei nu se află în palindrom.

(1 Dacă i = j
T(i,j) = 2 + T(i + 1,j - 1) Dacă i < j și x[i] = x[j]
[ max{T (i + 1,j), T (i,j — 1) } altfel

Pentru consistență set T (i, i - 1) = 0 pentru toate i.

Algoritm: Se calculează T(i, j) în ordinea creșterii lungimii intervalului |j - i|.

1
 pentru i = 2 până la n + 1:
T[i, i - 1] = 0 pentru i = 1 la n:
T[i,i]=1
pentru d = 1 la n - 1: (lungimea intervalului)
pentru i = 1 la n - d:
j=i+d
dacă x[i] = x[j]:
T[i,j]=2+T[i+1,j-1]
altfel:
T[i,j] =max{T[i+1,j],T[i,j-1]} returnează T[1, n]

Durata spectacolului: Există subprobleme O(n 2) și fiecare are nevoie de O(1) timp pentru calcul, deci timpul total de rulare
este O( ).
n2

4. Problema manualului 6.17.

Subproblemă: Pentru orice întreg 0 ≤ u ≤ v, definiți T (u) ca fiind adevărat dacă este posibil să faceți modificări pentru dvs.
folosind monedele date x1 , x2 , . . . , xn . . Răspunsul pe care îl dorim este T (v).
Formulare recursivă: Observați că

T (u) este adevărat dacă și numai dacă T (u - x i) este adevărat pentru unii . i

Pentru consecvență, setați T (0) la true.

Algoritm:

T [0] = adevărat
pentru u = 1 la v:
T [u] = fals
pentru i = 1 la n:
dacă ≥ x i și T [u - x ]: T [u] = adevărat
i

Durata spectacolului: Tabelul are dimensiunea v și fiecare intrare necesită O(n) timp pentru a fi completată; prin urmare,
timpul total de funcționare este O(nv).

5. Numărul de căi dintr-un GCI.

Subproblemă: Să presupunem că G este un grafic aciclic direcționat. Pentru orice nod v din grafic, definiți numpaths[v] ca
fiind numărul de căi de la s la v. Cantitatea pe care o dorim este numpaths[t].
Formulare recursivă: Alegeți (u, v) orice nod v 6= s din grafic. Orice traseu de la s la v se termină într-o muchie
∈ E . Astfel:
numpaths[v] = numpaths[u].
u:(u,v)∈E

Și, desigur, numpaths[s] = 1.

Algoritm: Putem completa matricea luând în considerare nodurile în ordine topologică:

Găsiți o ordonare topologică a lui G pentru toate v ∈ V :

numpaths[v] = 0
numpaths[s] = 1
pentru toate u ∈ V , în ordine topologică:
pentru toate (u, v) ∈ E:
numpaths[v] = numpaths[v] + numpaths[u] return numpaths[t]

Durata spectacolului: Timpul total de rulare este O(V + E), liniar.

6. Problema manualului 6.21.

Subproblemă: Rădăcinați arborele la orice nod r. Pentru fiecare u ∈ V , definiți

T(u) = dimensiunea celui mai mic înveliș de vârf al subarborelui înrădăcinat la u.

Vrem T (r).

2
 Formulare recursivă: În determinarea lui T (u), întrebarea cea mai imediată este dacă u se află în capacul vârfului. Dacă nu,
atunci copiii săi trebuie să fie în capacul vârfului. Lăsați C(u) să fie setul copiilor voștri și lăsați-l pe G(u) să fie nepoții săi.
Apoi

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

unde |C (u)| este numărul de copii ai nodului u. Primul caz include u în capacul vârfului; Al doilea caz nu face acest lucru.
Algoritm:

Alegeți orice nod rădăcină r

dist[·] = BFS(arbore, r)

Pentru toate nodurile u, în ordinea descrescătoare a dist:

51 = 1 (opțiunea 1: includeți u în capacul vârfului)
pentru toate (u, w) ∈ E astfel încât dist[w] = dist[u] + 1: (adică w = copilul tău):
S 1 = S1 + T [w]
52 = 0 (opțiunea 2: nu includeți u în capacul vârfului)
pentru toate (u, w) ∈ E astfel încât dist[w] = dist[u] + 1: (adică w = copilul tău):
S 2 = S2 + 1
pentru toți (w, z) ∈ E astfel încât dist[z] = dist[w] + 1: (adică z = nepotul tău):
S 2 = S2 + T [z]
T[u] = min{S1,S 2}
întoarcere T [r]

Durata spectacolului: Munca depusă la fiecare nod este proporțională cu numărul său de nepoți, |G(u)|. Pentru că u |G(u)| ≤ |
V | (fiecare nod are cel mult un bunic), munca generală efectuată este liniară.

7. Problema manualului 6.19.

Subproblemă: Pentru orice numere întregi 0 ≤ u ≤ v și 0 ≤ j ≤ k, definiți T (u, j) ca fiind adevărat dacă este posibil să faceți
modificări pentru dvs. folosind cel mult j monede cu valori nominale alese dintre x 1 , x2 , . . . , xn. Răspunsul pe care îl dorim
este T (v, k).
Formulare recursivă: Observați că

T(u, j) este adevărat dacă și numai dacă (fie u = 0, fie (T(u - x i,j - 1) este adevărat pentru unii i)).

Pentru consecvență, setați T (0, j) la true pentru toate j și T (u, 0) la false pentru dvs. > 0.
Algoritm:

pentru j = 0 la k:
T [0, j] = adevărat
pentru u = 1 la v:
T [u, 0] = fals
pentru j = 1 la k:
pentru u = 1 la v:
T [u, j] = fals
pentru i = 1 la n:
dacă ≥ x i și T [u - xi, j - 1]: T [u, j] = adevărat
returnează T [v, k]

Durata spectacolului: Tabelul are dimensiunea k × v și fiecare intrare necesită O(n) timp pentru a fi completată; prin urmare,
timpul total de funcționare este O (nkv).