Sei sulla pagina 1di 116

Esercizi di

Algoritmi e
Strutture Dati
Moreno Marzolla
http://www.moreno.marzolla.name/
Ultimo Aggiornamento: 13 ottobre 2014
Copyright
Copyright 2012, 2013, 2014 Moreno Marzolla. Quest'opera stata rilasciata con licenza Creative
Coons !ttri"uzione # Con$ivi$i allo stesso o$o 4.0 %nternazionale. &er leggere una copia $ella licenza
visita il sito 'e" http())creativecoons.org)licenses)"y#sa)4.0)$ee$.it.
Commenti
*uggerienti e correzioni sono "envenuti( scrivetei all'in$irizzo oreno.arzolla+uni"o.it.
Ultima versione
,a versione pi- recente $i .uesto $ocuento /in 0orato &12 e ,i"re300ice4 si trova all'in$irizzo
http())'''.oreno.arzolla.nae)
Immagine di copertina
Ciascun ri.ua$ro rappresenta il contenuto $i un vettore che viene or$inato con $iversi algoriti $i
or$inaento. %l vettore inizializzato con una perutazione casuale $egli interi copresi tra 1 e 5000. ,e
iagini $ella pria riga si ri0eriscono all'algorito 6u""le*ort, .uelli $ella secon$a riga all'algorito
Merge*ort, e .uelli $ella terza riga all'algorito Quic7*ort.
Ultimo aggiornamento
13 otto"re 2014
Indice
%ntro$uzione..................................................................................................................................................... 8
Capitolo 1( 9otazioni !sintotiche....................................................................................................................:
Capitolo 2( *trutture 1ati ;leentari............................................................................................................18
Capitolo 3( 3r$inaento e <icerca................................................................................................................45
Capitolo 4( =ashing....................................................................................................................................... >1
Capitolo 5( 1ivi$e et %pera..........................................................................................................................>5
Capitolo >( ?ecniche @ree$y.......................................................................................................................... 85
Capitolo 8( &rograazione 1inaica.........................................................................................................8:
Capitolo A( @ra0i.......................................................................................................................................... 105
Capitolo :( ;sercizi $i &rograazione......................................................................................................11:
6i"liogra0ia.................................................................................................................................................. 128
Introduzione
Questo $ocuento raccoglie alcuni esercizi proposti a partire $all'!nno !cca$eico 200:)2010 nell'a"ito
$el corso $i !lgoriti e *trutture 1ati, corso $i laurea in %n0oratica per il Manageent, BniversitC $i
6ologna.
@li esercizi sono raggruppati per argoentoD all'interno $ello stesso argoento vengono presentati senza
alcun or$ine particolare. !lcuni $egli esercizi sono tratti $a prove $'esae, altri sono stati svolti a lezione.
!lcuni esercizi sono tratti $a Cail 1eetrescu, %rene 2inocchi, @iuseppe 2. %taliano, Algoritmi e strutture
dati 2/ed, Mc@ra'#=ill, 200A, %*69( :8A AA 3A> >4>A8, o $a corsi $i !lgoriti svolti in altri !tenei.
9aturalente tutti gli errori sono $a attri"uire esclusivaente a e.
@li algoriti vengono presentati e$iante pseu$oco$ice, utilizzan$o una sintassi ispirata al linguaggio
&ascal 0orteente sepli0icato. ,a notazione usata $ovre""e risultare ie$iataente coprensi"ile a
chiun.ue sia 0ailiare con un linguaggio $i prograazione iperativo coe il C)CEE o Fava.
Avvertenza( .uesto $ocuento $a consi$erarsi G'or7 in progressH, e$ soggetto a o$i0iche e correzioni
0re.uenti. %n .uesta 0ase vengono scoperti errori e)o iprecisioni $i varia natura, per cui si raccoan$a la
assia cautela nell'uso $el ateriale.
,a versione pi- recente $isponi"ile all'in$irizzo http())'''.oreno.arzolla.nae) . 3ltre alla versione
&12, il sito ospita anche la versione e$ita"ile in 0orato 3pen300ice),i"re300ice, in o$o che chi $esi$era
personalizzare .uesto $ocuento possa 0arlo. <icor$o che ogni nuova versione $eve coun.ue essere resa
$isponi"ile con licenza Creative Coons !ttri"uzione # Con$ivi$i allo stesso o$o 4.0 %nternazionale. &er
leggere una copia $ella licenza visita il sito 'e" http())creativecoons.org)licenses)"y#sa)4.0)$ee$.it.
6ologna, 13 otto"re 2014
Capitolo 1: Notazioni Asintotiche
Esercizio 1.1
*ia f/n4 = n/n+14)2. Btilizzan$o la $e0inizione $i 3/ 4, $iostrare o con0utare le seguenti a00erazioni(
1. f/n4 = 3/n4
2. f/n4 = 3/n
2
4
Richiamo teorico. 1ate $ue 0unzioni costo f/n4 e g/n4, $iciao che f/n4 I 3/g/n44 se esistono costanti cJ0 e
n0K0 tali che f/n4 L cg/n4 per ogni nn0
Soluzione. &roviao a $iostrare se f/n4 = 3/n4. &er $e0inizione, $o""iao trovare una costante positiva
cJ0 tale che per ogni nKn
0
si a""ia f/n4 L cn. &roviao a sviluppare la $isuguaglianza(
n(n+1)
2
cn
n+1
2
c
3sserviao che non esiste nessuna costante c che so$$is0i la relazione prece$ente per ogni n
su00icienteente gran$e, .uin$i l'a00erazione f/n4 = 3/n4 0alsa.
&roviao ora a veri0icare se f/n4 = 3/n
2
4. Coe pria, cerchiao una costante c>0 per cui f/n4 cn
2
per
ogni nKn
0
.
n(n+1)
2
cn
2
n
2
+n
2n
2
c
1
2
+
1
2n
c
Consi$eriao l'ultia $isuguaglianza. &er ogni nK1 possiao scrivere(
1
2
+
1
2 n

1
2
+
1
2
=c
per cui sceglien$o cI1 e n
0
I1 la relazione veri0icata per ogni nKn
0
. Quin$i l'a00erazione f/n4 = 3/n
2
4
vera.
Esercizio 1.2
*i consi$eri la 0unzione FUN(n), con n K 1 intero, $e0inita $al seguente algorito ricorsivo(
10 Capitolo 1( 9otazioni !sintotiche 63MM!
algoritmo FUN( int n ) int
if (n 2) then
return n!
else
return FUN(n"1) " 2#FUN(n"2)!
endif
1. 1eterinare un liite in0eriore su00icienteente accurato $el tepo $i esecuzione T/n4
2. 1eterinare un liite superiore su00icienteente accurato $el tepo $i esecuzione T/n4
Soluzione. %l tepo $i esecuzione T/n4 puN essere calcolato coe soluzione $ella seguente e.uazione $i
ricorrenza(
T (n)=
{
c
1
sen2
T (n1)+T (n2)+c
2
altrienti
con c
1
e c
2
opportune costanti positive. &er stu$iare il valore $i T/n4 iportante osservare che la 0unzione
T/n4 onotona crescente, ossia risulta T/n4 K ?/n # 14. 1a .uesta osservazione possiao scrivere(
T (n) = T (n1)+T (n2)+c
2
2T (n1)+c
2
4T (n2)+2 c
2
+c
2
AT (n3)+4c
2
+2 c
2
+c
2

2
k
T (nk )+

i=0
k1
2
i
c
2

2
n
T (0)+

i=0
n1
2
i
c
2
= 2
n
c
1
+(2
n
1) c
2
= 2
n
(c
1
+c
2
)c
2
$a cui possiao conclu$ere che T/n4 I 3/2
n
4.
<agionan$o in aniera siile, possiao scrivere
T (n) = T (n1)+T (n2)+c
2
2T (n2)+c
2
4T (n4)+2c
2
+c
2
AT (n>)+4c
2
+2 c
2
+c
2

2
k
T (n2 k)+

i=0
k1
2
i
c
2

2
n/2
T (n2n/2)+

i=0
n/21
2
i
c
2
= 2
n/2
c
1
+(2
n/2
1)c
2
= 2
n/2
(c
1
+c
2
)c
2
$a cui possiao conclu$ere the T (n)=(2
n/ 2
) .
11
Esercizio 1.3
*crivere un algorito il cui costo coputazionale T/n4 sia $ato $alla seguente relazione $i ricorrenza(
T (n)=
{
O(1) se n10
nT (n1)+O(1) altrienti
$ove n un paraetro intero positivo passato coe input all'algorito. 9on richiesto il calcolo $ella
soluzione $ella ricorrenza, nO richiesto che l'algorito pro$uca un risultato $i una .ualsivoglia utilitC
pratica.
Soluzione. Bn possi"ile algorito il seguente
algoritmo FUN( int n ) int
if ( n 10 ) then
return 1!
else
int a :$ 0!
for i :$ 1 to n do
a :$ a % FUN(n"1)!
endfor
return a!
endif
Esercizio 1.
*upponiao $i $isporre $i un Gcoprocessore specialeH in gra$o $i 0on$ere $ue array or$inati, aventi
coplessivaente n eleenti, in tepo O(n) . 1eterinare il costo coputazionale $ell'algorito $i
or$inaento M&'(&)*'+ visto a lezione, in cui la 0ase $i 0usione $ei /sotto#4vettori or$inati viene realizzata
e$iante il coprocessore speciale $i cui sopra.
Richiamo teorico. /Master ?heore4 ,'e.uazione $i ricorrenza(
T (n)=
{
1 se n=1
aT
(
n
b
)
+ f (n) se n>1
ha coe soluzione(
1
T (n)=(n
log
b
a
)
se
f (n)=O(n
log
b
a
)
per un .ualche P J 0D
2
T ( n)=(n
log
b
a
log n)
se
f (n)=(n
log
b
a
)
3 T (n)=( f (n)) se
f (n)=(n
log
b
a+
)
per un .ualche P J 0 e se af/n)b4 L cn per cQ1 e n
su00icienteente gran$e
Soluzione. ,'e.uazione $i ricorrenza che $escrive il costo coputazionale $i M&'(&)*'+, nel caso si usi il
GcoprocessoreH, la seguente(
T(n)=
{
1 sen1
2T (n/2)+n altrimenti
!pplican$o il Master ?heore, con a=2, bI2, f (n)=(n) , si rica$e nel caso 14, che ha coe soluzione
T/n4 I R/n4
Esercizio 1.!
*i consi$eri il seguente algorito ricorsivo(
12 Capitolo 1( 9otazioni !sintotiche 63MM!
algoritmo FUN( arra" A,1..n- .i dou#le/ int i/ int 0 ) dou#le
if ( i 1 0 ) then
return 0!
elseif ( i $$ 0 ) then
return A,i-!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
return FUN(A/ i/ m) % FUN(A/ m%1/ 0)!
endif
,'algorito accetta coe paraetri un array AS1..nT $i n nueri reali e $ue interi i, jD l'algorito viene
inizialente invocato con FUN/A, 1, n4 e restituisce un nuero reale.
1. *crivere la relazione $i ricorrenza che $escrive il costo coputazionale $i FUN in 0unzione $i n
2. <isolvere la ricorrenza $i cui al punto 1.
3. Cosa calcola FUN/A, 1, n4 U /spiegare a parole4
Soluzione. ,a 0unzione FUN calcola la soa $ei valori presenti nel vettore AS1..nT. %l costo coputazionale
T/n4 so$$is0a la seguente e.uazione $i ricorrenza(
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
che, in "ase al Master ?heore /caso 1, con aI2, bI2, f/n4Ic
2
4 ha soluzione T/n4 I R/n4
Esercizio 1.$
1eterinare in o$o esplicito il costo coputazionale $el seguente algorito ricorsivo(
algoritmo FUN( int n ) int
if ( n 3 1 ) then
return n!
else
int a :$ 1!
for 4 :$ 1 to n do
a :$ a#2!
endfor
return a % 2#FUN(n/2)!
endif
Soluzione. %l costo T/n4 so$$is0a l'e.uazione $i ricorrenza(
T (n)=
{
c
1
se n1
T (n/2)+c
2
n altrienti
che in "ase al caso 34 $el Master ?heore /aI1, bI2, f/n4 I c
2
n4 ha coe soluzione T/n4 I R/n4
Esercizio 1.%
*i consi$eri l'algorito seguente, che accetta in input un intero positivo n
algoritmo FUN( int n ) int
if ( n 3 1 ) then
return n!
else
return 10#FUN(n/2)!
endif
13
Calcolare il costo coputazionale asintotico $ell'algorito in 0unzione $i n.
Soluzione. %l costo coputazionale T/n4 so$$is0a l'e.uazione $i ricorrenza
T (n)=
{
c
1
se n1
T (n/2)+c
2
altrienti
che in "ase al Master ?heore ha soluzione T/n4 I 3/log n4
Esercizio 1.&
*i consi$eri il seguente algorito ricorsivo che accetta in input un intero n 0
algoritmo FUN( int n ) int
if ( n 1 1 ) then
int a :$ 0!
for i:$1 to n"1
for 0:$i%1 to n do
a :$ a % 2 # (i % 0)!
endfor
endfor
for i :$ 1 to 15 do
a :$ a % FUN(n/4)!
endfor
return a!
else
return n"1!
endif
1eterinare il costo coputazionale T/n4 $ell'algorito, in 0unzione $el paraetro n.
Soluzione. ,'e.uazione $i ricorrenza la seguente(
T (n)=
{
c
1
se n1
1>T
(
n
4
)
+(n
2
) altrienti
Che in "ase al Master ?heore /caso 2, con aI1>, bI4, f/n4 I R/n
2
4 4 ha soluzione T/n4 I R/n
2
log n4
Esercizio 1.'
*i consi$erino i $ue algoriti seguenti(
algoritmo A2(A( int n ) int
if ( n 3 1 ) then
return 2#n!
else
int a :$ 2!
for i :$ 1 to n/2 do
a :$ a % 2#i!
endfor
return A2(A( n/2 ) % A2(A( n/2 ) % a!
endif
algoritmo A2(6( int n ) int
int a :$ 1!
for i :$ 1 to n .o
for 0 :$ 1 to n/2 do
a :$ a % i % 0!
endfor
endfor
return a!
1. Calcolare il costo coputazionale $i A2(A in 0unzione $i n.
14 Capitolo 1( 9otazioni !sintotiche 63MM!
2. Calcolare il costo coputazionale $i A2(6 in 0unzione $i n.
Soluzione. A2(A un algorito ricorsivo, per cui necessario innanzitutto scrivere l'e.uazione $i ricorrenza
per il tepo $i esecuzione T/n4 in 0unzione $ella $iensione $ell'input /in .uesto caso, il valore $i n4. *i ha(
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
n altrienti
/il terine c
2
n $eriva $al ciclo G0orH che ha costo /n4 4. ,'applicazione $el Master ?heore /caso 2, con
aI2, bI2, f/n4 I c
2
n4 $a coe risultato T/n4 I /n log n4.
A2(6 invece un algorito iterativo. %l corpo interno $ei $ue cicli G0orH ha costo 3/14 e viene eseguito
esattaente n n)2 volteD il costo coplessivo $ell'algorito .uin$i /n
2
4
Esercizio 1.1(
*crivere un algorito ricorsivo FUN( arra" A,1..n- .i int/ int i/ int 0 ) tale che il costo T/n4 $ell'invocazione
FUN(A/ 1/ n) so$$is0i la seguente relazione $i ricorrenza(
Soluzione. Bna tra le tante possi"ilitC la seguente(
algoritmo FUN( arra" A,1..n- .i int/ int i/ int 0 ) int
if ( 0 " i % 1 3 10 ) then
return 0!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
int a :$ FUN(A/ i/ m)! // costo T(n/2)
int b :$ FUN(A/ i/ 0 7 1 )! // costo T(n-1)
int 8 :$ 0!
for 4 :$ i to 0 do // costo (n
8 :$ 8 % 4!
endfor
return a % b % 8!
endif
%l punto iportante $i .uesto esercizio .uello $i osservare che la $iensione $ell'input $a consi$erare per
l'analisi $elle chiaate ricorsive la parte $i array copresa tra gli estrei i e j /.uesto esattaente .uello
che a""iao visto in altri algoriti, coe a$ esepio l'algorito $i ricerca "inaria, oppure in algoriti $i
or$inaento ricorsivi coe 9U:;<)*'+ o M&'(&)*'+4. Quin$i a$ esepio, scrivere la con$izione $ell'i0 coe
if (n 3 10) then // SBAGLIATO
non sare""e stato corretto, in .uanto la $iensione $ell'input /nuero $i eleenti $i A copresi tra le
posizioni i e j4 /j V i E 14.
Esercizio 1.11
%l pro0essor ?ritonacci ha $e0inito la se.uenza $i nueri $i ?ritonacci ?ri/n4, con n I 0, 1, 2, W nel o$o
seguente(
Tri(n)=
{
1 se n2
Tri (n1)+Tri (n2)+Tri (n3) altrienti
T (n)=
{
O(1) se n10
T (n/2)+T (n1)+cn altrienti
15
%l pro0essore a00era che il seguente algorito ricorsivo +':+*NA;;:':; la soluzione pi- e00iciente per
calcolare il valore $ell'n#esio nuero $i ?ritonacci(
+':+*NA;;:':;( integer n ) integer
if ( n 3 2 ) then
return 1!
else
return +':+*NA;;:':;(n"1) % +':+*NA;;:':;(n"2) % +':+*NA;;:':;(n"3)!
endif
Calcolare il costo asintotico $ell'algorito +':+*NA;;:':;/n4 in 0unzione $i n. 1iostrare che il pro0essor si
s"aglia proponen$o un algorito pi- e00iciente per calcolare il valore $i ?ri/n4.
Soluzione. %l tepo $i esecuzione T/n4 $ell'algorito +':+*NA;;:':;/n4 so$$is0a la seguente e.uazione $i
ricorrenza(
T (n)=
{
c
1
se n2
T (n1)+T (n2)+T (n3)+c
2
altrienti
3sservan$o che la 0unzione T/n4 onotona, cio T/n4 K T/n#14, per n K 3 possiao scrivere(
T (n)=T (n1)+T (n2)+T (n3)+c
2
3T (n3)+c
2
<ipeten$o k volte la sostituzione si ha(
T (n)=3
k
T (n3k )+3
k1
c
2
+3
k2
c
2
++c
2
$a cui si puN conclu$ere che T (n)=(3
n/3
) /si ve$a l';sercizio1.24. Quin$i l'algorito +':+*NA;;:':; ha
costo esponenziale in n.
&er calcolare in o$o e00iciente l'n#esio nuero $i ?ritonacci possiao applicare le stesse i$ee che portano
a$ algoriti e00icienti per il calcolo $ei nueri $ella se.uenza $i 2i"onacci. %n particolare, l'algorito
+':+*NA;;::+&' calcola ?ri/n4 in tepo /n4 usan$o spazio 3/14
+':+*NA;;::+&'( int n ) int
if ( n 3 2 ) then
return 1!
else
int tri0 :$ 1/ tri1 :$ 1/ tri2 :$ 1/ tri3!
for i :$ 3 to n do
tri3 :$ tri2 % tri1 % tri0!
tri0 :$ tri1!
tri1 :$ tri2!
tri2 :$ tri3!
endfor
return tri3!
endif
Capitolo 2: Strutture Dati
Elementari
Esercizio 2.1
*crivere un algorito e00iciente per risolvere il seguente pro"lea( $ato un array AS1..nT $i nJ0 valori reali,
restituire true se l'array A rappresenta un in#heap "inario, false altrienti. Calcolare la coplessitC nel caso
pessio e nel caso ottio $ell'algorito proposto, otivan$o le risposte.
Richiamo teorico. Bn in#heap un al"ero "inario in cui a$ ogni no$o v associato un valore !.val. Bno heap
go$e $elle seguenti propritC( /14 l'al"ero copleto 0ino al penultio livelloD /24 le 0oglie sono GaccatastateH a
sinistraD /34 il valore associato a$ ogni no$o inore o uguale al valore associato ai 0igli /se esistono4.
;' possi"ile rappresentare uno heap con n eleenti e$iante un array AS1..nT, sepliceene eorizzan$o i
valori $ello heap Gper livelliH. ,'eleento il cui valore eorizzato in posizione i nell'array avrC i valori $ei
0igli eorizzati negli eleenti in posizione 2Xi e 2XiE1, rispettivaente.
Soluzione. ,'algorito puN essere espresso coe segue(
algoritmo ;he84M:N=&A>( arra" A,1..n- .i dou#le ) #ool
for i :$ 1 to n do
if ( 2#i 3 n ?? A,i- 1 A,2#i- ) then
return @alAe!
endif
if ( 2#i%1 3 n ?? A,i- 1 A,2#i%1- ) then
return @alAe!
endif
endfor
return trBe!
*i noti i controlli (2#i3n) e (2#i%13n)/ che sono necessari per essere sicuri che i 0igli $ell'eleento ASiT
/rispettivaente AS2XiT e AS2XiE1T4 non ca$ano 0uori $all'array. *e tali controlli sono oessi, l'algorito
s"agliato in .uanto puN causare l'in$icizzazione $i un array al $i 0uori $ei liiti.
%l caso pessio si ha .uan$o il ciclo G0orH viene eseguito interaente, ossia .uan$o l'array AS1..nT
e00ettivaente rappresenta un in#heap. %n .uesto caso il costo 3/n4.
%l caso ottio si veri0ica .uan$o la ra$ice AS1T risulta aggiore $i uno $ei $ue 0igli /AS2T o AS3T, se
esistono4. %n .uesto caso il ciclo G0orH esce alla pria iterazione restituen$o false, e il costo risulta 3/14.
Esercizio 2.2
%l pro0essor &. 9occhio $ichiara $i aver inventato una rivoluzionaria struttura $ati( i &9#=eap. Bn &9#=eap
supporta le seguenti operazioni, tutte "asate unicaente su con0ronti( creazione $i un &9#=eap a partire $a
una collezione $i n eleenti con0ronta"ili in tepo O/n4D in$ivi$uazione $ell'eleento inio /o assio4
in tepo 3/14D riozione $ell'eleento inio /o assio4 in tepo 3/14. % costi sono tutti nel caso
pessio.
1A Capitolo 2( *trutture 1ati ;leentari 63MM!
1eterinare il costo coputazionale $i un ipotetico algorito $i or$inaento >N"=&A>)*'+ ottenuto
co"inan$o =&A>)*'+ con la struttura $ati &9#=eap. !lla luce $ella risposta alla $oan$a prece$ente, vi
0i$ate $ella scoperta $el pro0essor &. 9occhioU
Soluzione. *criviao lo pseu$oco$ice $i un ipotetico algorito $i or$inaento >N"=&A>)*'+, che "asato
sullo schea $i =&A>)*'+ a anzichO un norale heap, 0acciao uso $i un &9#=eap /&=4(
algoritmo >N"=&A>)*'+( arra" A,1..n- .i dou#le )
= :$ >N"=&A>:FC(A)! // Crea un PN-Heap a partire da!arra" A
for i :$ 1 to n do
A,i- :$ =.M:N()! // estrae i #ini#o da PN-Heap
=.D&2&+&M:N()! // cancea i #ini#o da PN-Heap
endfor
&er ipotesi, la creazione $el &9#=eap richie$e tepo 3/n4D il ciclo G0orH che segue viene eseguito n volte, e
ogni iterazione ha costo 3/14 /in .uanto per ipotesi le operazioni $i ricerca $el inio e cancellazione $el
inio costano entra"e 3/14 in un &9#=eap4. Quin$i il costo $el ciclo G0orH coplessivaente 3/n4.
,'algorito >N"=&A>)*'+ ha costo coputazionale coplessivo 3/n4.
*e i &9#=eap 0unzionassero coe $ichiarato, l'algorito >N"=&A>)*'+ sare""e un algorito $i or$inaento
"asato su con0ronti che or$ina un array $i n eleenti in tepo 3/n4. ;' noto perN che tale algorito non puN
esistere, in .uanto il liite in0eriore $ella coplessitC $el pro"lea $ell'or$inaento "asato su con0ronti
Y/n log n4. Quin$i non c' $a 0i$arsi $el pro0essor &. 9occhio.
Esercizio 2.3
*i consi$eri un al"ero "inario $i ricerca non "ilanciato, inizialente vuoto. 1isegnare gli al"eri che risultano
$opo l'inseriento $i ciascuna $elle seguenti chiavi nueriche( 18, 8, :, #3, 20, 1:, 5, 2, >.
Richiamo teorico. Bn al"ero "inario $i ricerca /!6<4 un al"ero "inario in cui a ciascun no$o ! associata una
chiave !"ke#. %n un !6< vale la seguente proprietC( per ogni no$o !, tutte le chiavi contenute nel sottoal"ero
sinistro sono inori o uguali a !"ke#, e tutte le chiavi contenute nel sottoal"ero $estro sono aggiori o uguali a
!"ke#.
Soluzione. Ci liitiao a rappresentare l'al"ero 0inale ottenuto(
Esercizio 2.
*i consi$eri un al"ero "inario $ in cui a ciascun no$o t associata una chiave nuerica /reale4 t"ke#. 9on ci
sono chiavi ripetute, e tutte le chiavi appartengono all'intervallo Sa% bT
1. *crivere un algorito e00iciente che $ato in input l'al"ero $ e gli estrei a e b, restituisce true se e
solo se $ rappresenta un al"ero "inario $i ricerca. 9on consentito usare varia"ili glo"ali.
1E
E 20
"3 F 1F
G
2 5
1:
2. Calcolare il costo coputazionale nel caso ottio e nel caso pessio $ell'algorito $i cui al punto 1.
1isegnare un esepio $i al"ero che pro$uce un caso pessio, e un esepio $i al"ero che pro$uce il
caso ottio.
Soluzione. %nnanzitutto utile ricor$are che in un !6< i valori $el sottoal"ero sinistro $i un no$o t sono tutti
inori o uguali a t"ke#, entre i valori $el sottoal"ero $estro $i t sono tutti aggiori o uguali $i t"ke#. 9on
.uin$i su00iciente con0rontare t solaente con i propri 0igli. Bna possi"ile soluzione la seguente
algoritmo ;=&;<A6'( nodo t/ dou#le a/ dou#le b ) #ool
// ini$ia#ente t de%e essere a radice di B
if ( t $$ nBll ) then
return trBe!
else
return ( a t.4eH ?? t.4eH b ??
;=&;<A6'(t.le@t/ a/ t.4eH) ??
;=&;<A6'(t.right/ t.4eH/ b) )!
endif
,'algorito ricorsivo veri0ica che per ogni no$o ! valgano le seguenti con$izioni(
a t"ke#D
t"ke# bD
il sottoal"ero sinistro un !6< con chiavi aventi valori in Sa, t"ke#TD
il sottoal"ero $estro un !6< con chiavi aventi valori in St"ke#, bT.
%l costo nel caso ottio 3/14, e si veri0ica .uan$o la chiave presente nel 0iglio sinistro $ella ra$ice $i 6
viola la proprietC $i !6<D il costo nel caso pessio /n4, $ove n il nuero $i no$i $ell'al"ero, e si
veri0ica .uan$o $ e00ettivaente un !6<.
Esercizio 2.!
*i consi$eri un al"ero "inario $i ricerca $, non necessariaente "ilanciato, in cui a ciascun no$o t associata
una chiave nuerica /reale4 t"ke#. 9on ci sono chiavi ripetute"
1. *crivere un algorito e00iciente che $ato in input l'al"ero $ e $ue valori reali a e b, con a&b,
restituisce il nuero $i no$i la cui chiave appartiene all'intervallo Sa% bT /estrei inclusi4
2. Calcolare il costo coputazionale $ell'algorito $i cui al punto 1 nel caso ottio e nel caso pessio.
Soluzione. Z possi"ile risolvere il pro"lea utilzzan$o lo pseu$oco$ice seguente(
algoritmo ;*N+AN*D:A6( nodo t/ dou#le a/ dou#le b ) int
if ( t $$ nBll ) then
return 0!
else
if ( t.4eH I a ) then
return ;*N+AN*D:A6(t.right/ a/ b)!
elseif ( t.4eH 1 b ) then
return ;*N+AN*D:A6(t.le@t/ a/ b)!
else
return 1 % ;*N+AN*D:A6(t.le@t/ a/ b) % ;*N+AN*D:A6(t.right/ a/ b)!
endif
endif
%l caso peggiore si veri0ica .uan$o tutte le chiavi presenti nell'al"ero sono coprese nell'intervallo Sa% bTD in
tale situazione, l'algorito ;*N+AN*D:A6 sostanzialente e.uivalente /$al punto $i vista $el costo
coputazionale4 a$ un algorito $i visita $ell'al"ero /ogni no$o viene esainato una volta4. Quin$i, nel caso
peggiore l'algorito ;*N+AN*D:A6 ha costo R/n4, $ove n il nuero $i no$i $ell'al"ero.
%l caso igliore si veri0ica a$ esepio e00ettuan$o la chiaata ;*N+AN*D:A6(6/ 1/ 2) sull'al"ero $ avente la
struttura seguente(
20 Capitolo 2( *trutture 1ati ;leentari 63MM!
,'algorito terina in tepo 3/14, a prescin$ere $al nuero n $i no$i $ell'al"ero. Quin$i il costo nel caso
ottio 3/14.
Esercizio 2.$
*i consi$eri un al"ero "inario $i ricerca non "ilanciato, inizialente vuoto.
1. 1isegnare la struttura $egli al"eri risultanti $opo l'inseriento $i ognuna $elle seguenti chiavi,
nell'or$ine in$icato( 20, 3, 38, 30, 1, 15, 25, 32.
2. 1isegnare la struttura $ell'al"ero $opo la riozione $el valore 38.
Soluzione. ,'al"ero a sinistra rappresenta la situazione $opo aver inserito tutti i valoriD l'al"ero a $estra
rappresenta la situazione $opo la riozione $el valore 38.
Esercizio 2.%
*i consi$eri un al"ero "inario T, avente struttura ar"itraria, in cui ciascun no$o t contenga un nuero reale
t.!alD
1. *crivere un algorito e00iciente che, $ato in input T, restituisca la soa $ei valori contenuti in tutte
le 0oglieD se l'al"ero vuoto l'algorito restituisce zero. Z vietato usare varia"ili glo"ali.
2. !ssuen$o che l'al"ero T sia copleto e tutte le 0oglie si trovino sullo stesso livello, $eterinare
0oralente il costo coputazionale $ell'algorito in 0unzione $el nuero n $i no$i.
Soluzione.
algoritmo )*MMAF*(2:&( nodo t ) dou#le
if ( t $$ nBll ) then
return 0!
elseif ( t.le@t $$ nBll ?? t.right $$ nBll ) then
return t.Jal!
else
return )*MMAF*(2:&(t.le@t) % )*MMAF*(2:&(t.right)!
endif
3sserviao che in un al"ero "inario copleto e "ilanciato con n no$i, il nuero $i no$i nel sottoal"ero
$estro /o sinistro4 $ella ra$ice /n#14)2, che per n su00icienteente gran$e possiao approssiare con n)2.
4
G
5
20
3 3E
30 1 1G
2G 32
20
3 30
1 1G 2G 32
21
&ertanto, il costo T/n4 $ell'algorito )*MMAF*(2:& so$$is0a la seguente relazione $i ricorrenza(
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
la cui soluzione, in "ase al Master ?heore, T/n4 I R/n4.
Esercizio 2.&
*i consi$eri un al"ero "inario T, non necessariaente "ilanciato. 3gni no$o t $i T contiene un nuero reale
t"!al.
1. *crivere un algorito ricorsivo che accetta in input l'al"ero T e un intero k0, e restituisce la soa
$ei valori contenuti nei no$i che si trovano esattaente a pro0on$itC kD ricor$iao che la pro0on$itC
$i un no$o pari al nuero $i archi $el caino che lo collega con la ra$ice /la ra$ice ha
pro0on$itC zero4. *e non esistono no$i a pro0on$itC k, l'algorito ritorna zero.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1 in 0unzione $el nuero n $i
no$i $i T, nell'ipotesi in cui il valore $i k sia uguale alla pro0on$itC $ell'al"ero.
Soluzione.
algoritmo )*MMAN*D:>'*F<( nodo t/ int 4 ) dou#le
if ( t $$ nBll ) then
return 0!
elseif ( 4 $$ 0 ) then
return t.Jal!
else
return )*MMAN*D:>'*F<(t.le@t/ 4"1) % )*MMAN*D:>'*F<(t.right/ 4"1)!
endif
,'algorito viene inizialente invocato passan$o coe prio paraetro un ri0eriento alla ra$ice
$ell'al"ero. 9ell'ipotesi in cui k sia uguale alla pro0on$itC $ell'al"ero, il costo coputazionale R/n4 in
.uanto l'algorito coinci$e .uasi esattaente con un algorito $i visita copleta $ell'al"ero.
Esercizio 2.'
1. *crivere un algorito e00iciente che, $ato in input un al"ero "inario T, restituisce true se e solo se T
rappresenta un al"ero "inario copleto /ricor$iao che in un al"ero "inario copleto ogni no$o non
0oglia ha esattaente $ue 0igliD l'al"ero vuoto si assue copleto4.
2. Calcolare il costo coputazionale $ell'algorito $i cui al punto 1, nel caso venga applicato a$ un
al"ero copleto "ilanciato con n no$i.
Soluzione. Bna soluzione ricorsiva la seguente
algoritmo A26&'*6:N;*M>2&+*( nodo t ) #ool
if ( t $$ nBll ) then
return trBe! // caso &ase' !a&ero %uoto ( co#peto
elseif ( t.le@t K nBll ?? t.right K nBll ) then
return A26&'*6:N;*M>2&+*(t.le@t) ?? A26&'*6:N;*M>2&+*(t.right)!
elseif ( t.le@t $$ nBll ?? t.right $$ nBll ) then
return trBe! // !a&ero co#posto da una sin)oa *o)ia ( co#peto
else
return @alAe!
endif
%l costo T/n4 $ell'algorito applicato a$ un al"ero "inario copleto "ilanciato $i n no$i $escritto $alla
seguente relazione $i ricorrenza(
22 Capitolo 2( *trutture 1ati ;leentari 63MM!
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
la cui soluzione, in "ase al Master ?heore, T/n4 I R/n4.
Esercizio 2.1(
*i consi$eri un array 'S1..nT $i valori reali che contiene le variazioni $elle .uotazioni $i "orsa $elle azioni
!CM; *.p.!. $urante n 1 giorni consecutivi. Ciascun valore 'SiT puN essere positivo o negativo a secon$a
che al terine $el giorno i le azioni !CM; a""iano registrato un increento o una $iinuzione $el loro
valore rispetto alla .uotazione $i apertura $el giorno e$esio. 'SiT puN anche essere zero, nel caso in cui le
.uotazioni $elle azioni non a""iano su"ito variazioni.
*crivere un algorito e00iciente che, $ato in input l'array ', restituisca il assio nuero $i giorni
consecutivi in cui le azioni !CM; sono risultate in rialzo. %n altre parole, si chie$e $i $eterinare la
lunghezza assia $ei sottovettori $i ' costituiti $a valori contigui strettaente positivi. !$ esepio, se
'IS0.1, #0.A, 0.2, 0.3, 1.2, #0.:, 0.0, #1.8, #2T l'algorito $eve restituire 3, in .uanto esistono al pi- tre valori
positivi consecutivi /il sottovettore S0.2, 0.3, 1.2T4.
!nalizzare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. 1e0iniao un algorito $i costo ottio /lineare4 che 0unziona coe segue. Manteniao $ue
contatori, np /Gnuero positiviH4 e maLnp /Gassio nuero $i valori positiviH4 e$ esainiao a turno tutti
gli eleenti $i '. np rappresenta la lunghezza $ella se.uenza $i valori positivi consecutivi che inclu$e
l'eleento 'SiT che stiao esainan$o. *e 'SiT J 0, si increenta np e si aggiorna maLnp se necessarioD se
'SiT L 0, il valore $i np $iventa zero.
algoritmo 9U*+AM:*N:A;M&( arra" 9,1..n- .i dou#le ) int
int np :$ 0!
int maLnp :$ 0!
for i :$ 1 to n do
if ( 9,i- 1 0 ) then
np :$ np%1!
if ( np 1 maLnp ) then
maLnp :$ np!
endif
else
np :$ 0!
endif
endfor
return maLnp!
,'algorito ha costo R/n4. *i presti attenzione al 0atto che sare""e s"agliato spostare il "locco Ni@ (np 1
maLnp) O en.i@P nel rao GelseH $ell'i0 pi- esternoD in sostanza, l'algorito scritto coe segue non 0unziona(
algoritmo )6A(2:A+*( arra" 9,1..n- .i dou#le ) int
int np :$ 0!
int maLnp :$ 0!
for i :$ 1 to n do
if (9,i- 1 0) then
np :$ np%1!
else
if ( np 1 maLnp ) then // +uesto test ( s&a)iato in +uesta posi$ione,
maLnp :$ np!
endif
np :$ 0!
endif
endfor
23
return maLnp!
in .uanto pro$uce il risultato errato in casi coe 'IS0.1, 0.:, #2, 0.8, 1.2, 1.3T /(erc)*+4.
Esercizio 2.11
*i consi$eri un al"ero "inario T in cui a ciascun no$o ! associato un nuero reale t"!al. 1ato un .ualsiasi
caino che porta $alla ra$ice a$ una 0oglia, $e0iniao il costo $el caino coe la soa $ei valori
associati a tutti i no$i attraversati /inclusa la ra$ice e la 0oglia $i $estinazione4
1. *crivere un algorito che, $ato in input l'al"ero T, restituisce il costo assio tra tutti i caini
ra$ice#0oglia. 9el caso $i al"ero vuoto, l'algorito restituisce 0.
2. !nalizzare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Z possi"ile risolvere il pro"lea e$iante un algorito ricorsivo(
algoritmo ;AMM:N*>&)*MAQ( nodo t ) dou#le
if ( t $$ nBll ) then
return 0!
else
return t.Jal % maL( ;AMM:N*>&)*MAQ(t.le@t)/ ;AMM:N*>&)*MAQ(t.right) )!
endif
,a 0unzione maL(a/ b) restituisce il valore assio tra a e b. ,'algorito, applicato a$ un al"ero "inario con
n no$i, ha costo R/n4 in .uanto e.uivale a$ un algorito $i visita $ell'al"ero /esaina un no$o una e una
sola volta4. *e si assue che l'al"ero sia "ilanciato e copleto, si puN 0are una $iostrazione $iretta
scriven$o l'e.uazione $i ricorrenza T/n4 I 2T/n)24E3/14 e risolven$ola traite il Master ?heore.
Esercizio 2.12
*i consi$eri l'algorito 9U:;<F:ND con euristica sul peso. *crivere un algorito che crei nI1> insiei
$isgiunti, e$ e00ettui una serie $i operazioni UN:*N $i cui aleno una /a$ esepio, l'ultia4 richie$a n)2
ca"iaenti $el ri0eriento al pa$re. Z possi"ile 0are uso $i operazioni F:ND $urante l'esecuzione
$ell'algorito.
Richiamo teorico. 9elle strutture Quic72in$ l'operazione pi- e00iciente /coe $ice il noe4 l'operazione F:ND.
,e strutture Quic72in$ sono .uin$i rappresentate $a al"eri $i altezza 1, in cui la ra$ice $ell'al"ero il
rappresentante $ell'insiee. ,'operazione BN:*N consiste nel ren$ere le 0oglie $i uno $ei $ue al"eri 0iglie $ella
ra$ice $ell'altroD .uesto richie$e $i settare il ri0eriento al pa$re $i tutte le 0oglie.
Esercizio 2.13
*i consi$eri l'algorito 9U:;<UN:*N con euristica sul rango /altezza $egli al"eri 9U:;<UN:*N4. *crivere un
algorito che crei nI1> insiei $isgiunti, e$ e00ettui una serie $i operazioni UN:*N che al terine pro$ucano
un singolo al"ero /che corrispon$e al singolo insiee [1, W, 1>\ $i altezza assia possi"ile. *e
necessario, possi"ile 0are uso $i operazioni F:ND $urante l'esecuzione $ell'algorito.
Soluzione. <icor$iao che l'operazione union eseguita su al"eri 9U:;<UN:*N con euristica sul rango 0unziona
nel o$o seguente( si ren$e la ra$ice l'al"ero pi- "asso 0iglia $ella ra$ice $ell'al"ero pi- altoD in caso $i
unione $i al"eri aventi la stessa altezza, l'al"ero risultante crescerC in altezza $i uno.
algoritmo A26&'*9U:;<UN:*N( int n )
9U:;<UN:*N UF!
for i :$ 1 to n do
UF.MA<&)&+(i)!
endfor
int A :$ 1!
)hile ( A I n ) do
24 Capitolo 2( *trutture 1ati ;leentari 63MM!
for i :$ 1 to n step A do
UF.UN:*N(UF.F:ND(i)/ UF.F:ND(i%A))! // i nuo%o rappresentante ( i
endfor
A :$ A#2!
end)hile
Esercizio 2.1
*i consi$eri un al"ero "inario $i ricerca, non "ilanciato, in cui ciascun no$o contiene una chiave intera. 9on
ci sono chiavi ripetute. ,'al"ero ha inizialente la struttura seguente.
Mostrare la struttura $ell'al"ero $opo ciascuna $elle seguenti operazioni /ciascuna operazione si ri0erisce
all'al"ero risultante al terine $i .uella prece$ente4.
1. %nseriento 12
2. %nseriento 5
3. Cancellazione >
4. %nseriento 23
5. Cancellazione 10
>. %nseriento 1:
8. %nseriento >
Soluzione.
%nseriento 12
%nseriento 5
10
5 1R
1 F
R
10
5 1R
1 F
R
12
25
Cancellazione >
%nseriento 23
Cancellazione 10
%nseriento 1:
10
5 1R
1 F
R
12
G
10
G 1R
1 F
R
12
10
G 1R
1 F
R
12 23
F
G 1R
1 R 12 23
2> Capitolo 2( *trutture 1ati ;leentari 63MM!
%nseriento >
Esercizio 2.1!
*ia ,S1..nT un vettore non or$inato $i nueri reali che rappresenta il prezzo e$io giornaliero $elle azioni
$ella !CM; *.p.!. $urante n K 1 giorni successivi. ]ogliao calcolare il assio nuero $i giorni contigui
in cui il prezzo $elle azioni risulta non $ecrescente. %n altre parole, vogliao calcolare la lunghezza assia
tra tutti i sottovettori coposti $a eleenti contigui $i , che risultino or$inati in senso non $ecrescente.
*crivere un algorito per risolvere .uesto pro"lea, e $eterinarne il costo coputazionale.
!$ esepio, se ,IS1, 3, 2, 5, 1, 4, 8T l'algorito restituisce 3, in .uanto il sottovettore non $ecrescente
coposto $agli ultii tre eleenti S1, 4, 8T or$inato in senso crescente. !ltro esepio, se ,IS12, 3, 5, 8, A,
4, >T, l'algorito restituisce 4, in .uanto il pi- lungo sottovettore or$inato appunto S3, 5, 8, AT che ha 4
eleenti. Bltio esepio, se ,IS5, 4, 3, 2, 1T l'algorito ritorna 1, perchO gli unici sottovettori non
$ecrescenti sono i singoli eleenti $i ,.
Soluzione.
algoritmo 9U*+AM:*N&N*ND&;'&);&N+&( arra" >,1..n- .i dou#le ) int
int 2 :$ 1!
int maL2 :$ 1!
for i :$ 2 to n do
if ( >,i"1- 3 >,i- ) then
2 :$ 2 % 1!
if ( 2 1 maL2 ) then
maL2 :$ 2!
endif
else
2 :$ 1!
endif
endfor
return maL2!
%l costo $ell'algorito R/n4.
F
G 1R
1 R 12 23
1F
F
G 1R
1 R 12 23
1F
5
28
Esercizio 2.1$
*i consi$eri il a^#heap seguente(
Mostrare la struttura $el a^#heap $opo ciascuna $elle operazioni seguenti /ogni operazione viene copiuta
sul in#heap risultante $all'operazione prece$ente, e $eve essere eseguita e$iante gli algoriti $escritti nel
li"ro $i testo e visti a lezione4(
1. Cancellazione valore assio
2. Cancellazione valore assio
3. %nseriento 13
4. %nseriento 2A
5. Cancellazione valore assio
>. %nseriento 43
Soluzione.
1( Cancellazione valore assio
2( Cancellazione valore assio
3( %nseriento 13
23
15 1R
12 G 1E
1R
15 1E
12 G
1E
15 G
12
2A Capitolo 2( *trutture 1ati ;leentari 63MM!
4( inseriento 2A
5( Cancellazione assio
>( %nseriento 43
Esercizio 2.1%
1escrivere un algorito che $ato un array AS1..nT $i interi appartenenti all_insiee [1, 2, ... k\, preprocessa
l_array in tepo 3/n E k4 in o$o $a generare una opportuna struttura $ati che consenta $i rispon$ere in
tepo 3/14 a interrogazioni $el tipo( G.uanti eleenti $i A sono copresi nell_intervallo Sa, bTUH/per
.ualsiasi 1 L a L b L k% a e b interi4
Soluzione. ,'i$ea .uella $i costruire un array $i interi -S1..kT, tale che -SiT sia il nuero $i valori $i A che
1E
15 G
12 13
2R
15 1E
12 13 G
1E
15 G
12 13
43
15 1E
12 13 G
2:
sono inori o uguali a i. Bna volta costruito -, il nuero $i valori $i . che sono copresi in Sa, bT /-SbT V
-Sa#1T4 se aJ1, oppure -SbT se aI1.
*i tratta a .uesto punto $i capire coe costruire - in tepo coplessivo 3/nEk4. ,'i$ea .uella $i proce$ere
in $ue 0asi( nella pria 0ase costruiao un vettore /S1..kT in cui /SiT il nuero $i volte in cui il valore i
copare in AD usiao poi / per costruire -(
algoritmo ;*)+'U:);:)( arra" A,1..n- .i int ) arra",1..4- .i int
arra" F,1..4- .i int!
arra" ),1..4- .i int!
// Ini$iai$$ia#o -.1//01 a $ero
for i :$ 1 to 4 do
F,i- :$ 0!
endfor!
// Pri#a *ase2 costru$ione di -
for i :$ 1 to n do
F,A,i-- :$ F,A,i-- % 1!
endfor
// Seconda *ase2 costru$ione di S
),1- :$ F,1-!
for i :$ 2 to 4 do
),i- :$ ),i"1- % F,i-!
endfor
return )!
Esercizio 2.1&
*crivere un algorito che $ati in input un array AS1..nT non or$inato $i n valori reali positivi /strettaente
aggiori $i zero4 e un valore reale positivo !, restituisce true se e solo se esistono $ue valori in A la cui
soa sia esattaente uguale a !. !nalizzare il costo coputazionale $ell_algorito proposto.
Soluzione. 1escriviao un algorito "anale a non e00iciente che controlla tutte le coppie ASiT, ASjT, con 1
L i Q j L n per veri0icare se ASiT E ASjT I ! . ,o pseu$oco$ice il seguente
algoritmo &):)+&)*MMA( arra" A,1..n- .i dou#le/ dou#le J ) #ool
for i :$ 1 to n " 1 do
for 0 :$ i % 1 to n do
if (A,i- % A,0- $$ J) then
return trBe!
endif
endfor
endfor
return @alAe!
Bn errore "anale a che ho visto copiere pi- $i una volta .uello $i scrivere l'i0 pi- interno coe(
if (A,i- % A,0- $$ J) then
return trBe!
else
return @alAe! // SBAGLIATO,,,,,
endif
Questo sare""e s"agliato, in .uanto l'algorito terinere""e sepre alla pria iterazione, senza ai
controllare tutte le coppie.
%l costo coputazionale $ell'algorito 3/n
2
4. %l caso pessio si ha .uan$o non esiste alcuna coppia $i
in$ici che so$$is0ano la con$izione richiesta( in .uesto caso l'algorito richie$e tepo /n
2
4. %l caso ottio
si veri0ica .uan$o AS1T E AS2T I !, e in tal caso l_algorito terina in tepo 3/14 in .uanto la con$izione if
30 Capitolo 2( *trutture 1ati ;leentari 63MM!
(A,i- % A,0- $$ J) ie$iataente veri0icata.
%n realtC esiste una soluzione pi- e00iciente nel caso pessio, che consiste nell'or$inare il vettore A in senso
non $ecrescente, e ragionare coe segue. Consi$eriao i valori AS1T e ASnT /$ell'array or$inato4. *e la loro
soa vale !, a""iao terinato. *e AS1T E !SnT J !, sappiao che !SnT non puN 0ar parte $i alcuna coppia
$i valori la cui soa $ia !, in .uanto per ogni kI1, W, n#1 avreo ASkT E ASnT K AS1T E ASnT J ! , $ato che
ASkT K AS1T /essen$o A or$inato4. ]iceversa, se AS1T E ASnT Q !, sappiao che AS1T non puN 0ar parte $i
alcuna coppia $i valori la cui soa $ia !, $ato che per ogni k I 2, W, n si avre""e ASkT L ASnT, $a cui AS1T
E ASkT L AS1T E ASnT Q !.
,'algorito seguente risolve il pro"lea in tepo 3/n log n4, che il tepo richiesto per or$inare A usan$o
un argorito $i or$inaento e00iciente.
algoritmo &):)+&)*MMA( arra" A,1..n- .i dou#le/ dou#le J ) #ool
*'D:NA;'&);&N+&(A)!
int i :$ 1!
int 0 :$ n!
)hile ( i I 0 ) do
if ( A,i- % A,0- $$ J ) then
return trBe!
elseif ( A,i- % A,0- I J ) then
i :$ i % 1!
else
0 :$ 0 7 1!
endif
end)hile
return @alAe!
Esercizio 2.1'
*crivere un algorito che $ati in input un array AS1..nT $i n interi positivi restituisce true se e solo se
esistono $ue eleenti in A la cui soa sia esattaente uguale a 18. ,_algorito $eve avere costo 3/n4.
/*uggeriento( utilizzare un vettore $i 1> valori "ooleani $S1..1>T4. Cosa ca"ia se anzichO 18 si vuole
$eterinare se esistono $ue eleenti la cui soa sia uguale a 1>U
Soluzione. ,_i$ea la seguente( tutti gli eleenti $el vettore $ sono inizialente posti a false. *i e00ettua
.uin$i una pria scansione $ell_array A. &er ogni valore k [1, W, 1>\ presente in A si pone $SkT I true. !l
terine $i .uesta 0ase, per ogni intero k [1, W, 1>\ avreo che k presente in A se e solo se $SkT I true.
2acco ciN si esegue una secon$a 0ase in cui si e00ettua una scansione $i $, controllan$o se esiste un in$ice k
tale che $SkT I true e $S18 ` kT I true. %n "ase a .uanto appena $etto, se .uesto si veri0ica signi0ica che i
nueri k e /18#k4 sono entra"i presenti in AD $ato che la loro soa 18, l'algorito ritorna true.
algoritmo &):)+&;*>>:A1E( arra" A,1..n- .i int ) #ool
arra" 6,1..15- .i #ool
// Ini$iai$$a$ione
for 4 :$ 1 to 15 do
6,i- :$ @alAe!
endfor
// Pri#a *ase
for 4 :$ 1 to n do
if ( A,4- I 1E ) then
6,A,4-- :$ trBe!
endif
endfor
// Seconda *ase
for 4 :$ 1 to R do
if (6,4- $$ trBe ?? 6,1E"4- $$ trBe) then
return trBe!
endif
31
endfor
return @alAe!
!nalizziao il costo coputazionale $ell_algorito proposto. ,'inizializzazione /prio ciclo G0orH4 ha costo
3/14( si noti in0atti che e00ettua un nuero costante $i iterazioni che non $ipen$e $alla $iensione n
$ell'input, e ogni iterazione ha costo 3/14. la Gpria 0aseH ha costo R/n4. %n0ine, la Gsecon$a 0aseH ha costo
3/14 in .uanto anche .ui viene eseguito al pi- A volte, che una costante in$ipen$ente $alla $iensione
$ell'input, e ogni iterazione costa 3/14. %n sostanza, il costo coplessivo $ell'algorito R/n4.
!pplican$o l'algorito al vettore A $i 8 eleenti cosa coposto /i nueri $ella pria riga rappresentano gli
in$ici $elle celle $el vettore4(
0 2 1 2 3 4 5
13 1 12 4 4 1: 4
*i ottiene il vettore $ seguente(
0 2 1 2 3 4 5 6 7 00 00 02 01 02 03 04
? 2 2 ? 2 2 2 2 2 2 2 ? ? 2 2 2
e $ato che $S4T I $S18#4T I true, l'algorito restituisce true /la soa $ei valori 4 e 13 $a 184.
*e $o""iao cercare una coppia $i valori la cui soa sia 1>, anzichO 18, la soluzione sopra non 0unziona(
.uesto si puN veri0icare applican$o l_algorito appena visto /con l'ovvia o$i0ica $i ca"iare
opportunaente la $iensione $i $4 al vettore ! I SA, 5T. %l pro"lea che non pi- su00iciente sapere se un
certo valore copare in A, a anche 8uante !olte copare. %n0atti il nuero 1> si puN ottenere anche coe
AEA, a l'algorito &):)+&;*>>:A1E non tiene conto $el nuero $i volte in cui ciascun valore copare.
,a soluzione corretta in .uesto caso consiste nel $e0inire un vettore $ coposto $a 15 eleenti interiD $SkT
conterrC il nuero $i volte in cui il valore k copare nell'array A.
,'algorito puN essere $escritto coe segue(
algoritmo &):)+&;*>>:A15( arra" A,1..n- .i int ) #ool
arra" 6,1..1G- .i int
for 4 :$ 1 to 1G do
6,4- :$ 0!
endfor
for 4 :$ 1 to n do
if ( A,4- 3 1G ) then
6,A,4-- :$ 6,A,4--%1!
endif
endfor
for 4 :$ 1 to R do
if ( (4$$R ?? 6,4-11) SS (6,4-10 ?? 6,15"4-10) ) then
return trBe!
endif
endfor
return @alAe!
che ha costo /n4 coe il caso prece$ente.
&er $iostrare il 0unzionaento $ell'algorito &):)+&;*>>:A15, consi$eriao il vettore A seguente(
0 2 1 2 3 4 5
32 Capitolo 2( *trutture 1ati ;leentari 63MM!
12 1 12 A 4 1: 4
,'algorito pro$uce il vettore $
0 2 1 2 3 4 5 6 7 00 00 02 01 02 03
1 0 0 2 0 0 0 1 0 0 0 2 0 0 0
1ato che $S4TJ0 bb $S1>#4TJ0, l'algorito restituisce true.
Esercizio 2.2(
1ato un al"ero "inario T, scrivere un algorito che calcola la pro0on$itC $i TD l'algorito $eve restituire un
errore in caso $i al"ero vuoto /in0atti in .uesto caso la pro0on$itC non "en $e0inita4.
Richiamo teorico. ,a pro0on$itC $i un al"ero $e0inita coe il nuero $i archi $el caino pi- lungo tra la
ra$ice e una 0oglia. Questa $e0inizione non si puN applicare agli al"eri vuoti, $ato che non hanno alcun caino.
Soluzione . Bna possi"ile soluzione la seguente(
algoritmo >'*F*ND:+A( nodo + ) int
i@ ( + $$ nBll ) then
errore2 a&ero %uoto
endif
// Cacoa pro*ondit3 de sottoa&ero sinistro' se non %uoto
int pTle@t :$ 0!
if ( +.le@t K nBll ) then
pTle@t :$ 1 % >'*F*ND:+A(+.le@t)!
endif
// Cacoa pro*ondit3 de sottoa&ero destro' se non %uoto
int pTright :$ 0!
if ( +.right K nBll ) then
pTright :$ 1 % >'*F*ND:+A(+.right)!
endif
// 4estituisce i #assi#o tra a pro*ondit3 de sottoa&ero destro e sinistro
if (pTle@t 1 pTright) then
return pTle@t!
else
return pTright!
endif
Esercizio 2.21
1ato un al"ero "inario T, scrivere un algorito che calcola il nuero $i 0oglie $i T /le 0oglie sono i no$i che
non hanno 0igli4. !nalizzare il costo coputazionale $ell_algorito proposto. Quan$o si veri0ica il caso
ottioU Quan$o si veri0ica il caso pessioU
Soluzione . Bna possi"ile soluzione la seguente(
algoritmo ;*N+AF*(2:&( nodo + ) int
if ( + $$ nBll ) then
return 0!
else
if ( +.le@t $$ nBll ?? +.right $$ nBll ) then
return 1! // i nodo T ( una *o)ia
else
33
return ;*N+AF*(2:&(+.le@t) % ;*N+AF*(2:&(+.right)!
endif
endif
%l costo $ell_algorito eseguito su un al"ero con n no$i /n4 /sia nel caso ottio che nel caso pessio
l'algorito visita e tutti i no$i $ell_al"ero una e una sola volta4.
Esercizio 2.22
1ato un al"ero "inario T e un intero k K 0, scrivere un algorito che calcola il nuero $i no$i che si trovano
esattaente a pro0on$itC k /ricor$iao a che la ra$ice si trova a pro0on$itC zero4. !nalizzare il costo
coputazionale $ell_algorito proposto. Quan$o si veri0ica il caso ottioU Quan$o si veri0ica il caso
pessioU
Soluzione. Questo esercizio olto siile all';sercizio 2.A. Bna possi"ile soluzione la seguente(
algoritmo ;*N+AN*D:>'*F<( nodo +/ int 4 ) int
if ( + $$ nBll ) then
return 0!
else
if (4 $$ 0) then
return 1!
else
return ;*N+AN*D:>'*F<(+.le@t/ 4"1) % ;*N+AN*D:>'*F<(+.right/ 4"1)!
endif
endif
%l caso ottio si veri0ica .uan$o gli n no$i $ell'al"ero sono $isposti coe in una catena /l'al"ero $egenera in
una lista4. %n .uesto caso l'esplorazione $ell'al"ero riguar$a solo i prii k no$i $ella catena e poi si
interropeD il costo .uin$i 3/k4. %l caso peggiore si veri0ica .uan$o l'al"ero copleto 0ino al livello k,
cio tutti i no$i 0ino al livello k hanno esattaente $ue 0igli. <icor$an$o che un al"ero "inario copleto $i
altezza k ha esattaente /2
kE1
# 14 no$i, si ha che il costo coputazionale in .uesto caso 3/2
kE1
# 14 I 3/2
k
4.
Esercizio 2.23
*ono $ati $ue array AS1..nT e $S1..mT, coposti $a n 1 e$ m 1 nueri reali, rispettivaente. @li array
sono etra"i or$inati in senso crescente. A e $ non contengono valori $uplicati9 tuttavia, possi"ile che
uno stesso valore sia presente una volta in A e una volta in $.
1. *crivere un algorito e00iciente che stapi a vi$eo i nueri reali che appartengono all'unione $ei
valori $i A e $i $D l'unione intesa in senso insieistico, .uin$i gli eventuali valori presenti in
entra"i $evono essere stapati solo una volta. !$ esepio, se AIS1, 3, 4, >T e $IS2, 3, 4, 8T,
l'algorito $eve stapare 1, 2, 3, 4, >, 8.
2. 1eterinare il costo coputazionale asintotico $ell'algorito proposto, in 0unzione $i n e m.
Soluzione. Questo pro"lea puN essere risolto in o$o e00iciente utilizzan$o un eccaniso siile
all'operazione M&'(& $ell'algorito Merge*ort.
algoritmo UN:*N&( arra" A,1..n- .i dou#le/ arra" 6,1..m- .i dou#le )
int i:$ 1! // indice arra" A
int 0 :$ 1! // indice arra" B
)hile ( i 3 n ?? 0 3 m ) do
if ( A,i- I 6,0- ) then
print A,i-!
i :$ i%1!
else if ( A,i- 1 6,0- ) then
print 6,0-!
0 :$ 0%1!
34 Capitolo 2( *trutture 1ati ;leentari 63MM!
else
print A,i-!
i :$ i%1!
0 :$ 0%1!
endif
end)hile
// sta#pa a 5coda6 di ee#enti c7e e%entua#ente restano in uno dei %ettori/
// soo uno dei due cici 587ie6 se)uenti %erra! ese)uito
)hile ( i 3 n ) do
print A,i-!
i :$ i%1!
end)hile
)hile ( 0 3 m ) do
print 6,0-!
0 :$ 0%1!
end)hile
% $ue array A e $ vengono esainati utilizzan$o $ue cursori, i e j. !$ ogni passo, si con0ronta l'eleento ASiT
con l'eleento $SjT. *e tali valori $i00eriscono, si stapa il inio $ei $ue e si increenta il corrispon$ente
cursore. *e i valori sono uguali, se ne stapa uno /a$ esepio ASiT4 e si increentano entra"i i cursori.
Quan$o si raggiunge la 0ine $i uno $ei $ue vettori necessario ricor$arsi $i stapare tutti gli eleenti
resi$ui che si trovano eventualente nell'altro. %l costo $i .uesto algorito R/ n + m4 in .uanto
sostanzialente e00ettua una scansione $i entra"i i vettori esainan$o ciascun eleento una e una sola
volta in tepo 3/14.
Esercizio 2.2
*i consi$eri una struttura 9U:;<UN:*N con euristica sul rango /l'operazione UN:*N(A/ 6) ren$e la ra$ice
$ell'al"ero pi- "asso 0iglia $ella ra$ice $ell'al"ero pi- altoD in caso $i paritC, la ra$ice $i $ viene resa 0iglia
$ella ra$ice $i A4. %nizialente sono presenti nI10 insiei $isgiunti [1\, [2\, W [10\.
1isegnare gli al"eri 9U:;<UN:*N $ell'intera struttura union#0in$, $opo ciascuna $elle seguenti operazioni(
1. Bnion( @in.(1)/ @in.(2) )
2. Bnion( @in.(3)/ @in.(4) )
3. Bnion( @in.(G)/ @in.(5) )
4. Bnion( @in.(1)/ @in.(4) )
5. Bnion( @in.(1)/ @in.(G) )
>. Bnion( @in.(E)/ @in.(R) )
Esercizio 2.2!
*crivere un algorito che accetta in input $ue al"eri "inari T1 e T2 e restituisce true se e solo se T1 e T2
hanno la stessa struttura. 1ue al"eri hanno la stessa struttura se sono entra"i vuoti, oppure se sono entra"i
non vuoti e i sottoal"eri $estri e sinistri $elle ra$ici hanno rispettivaente la stessa struttura. !$ esepio,
.uesti $ue al"eri hanno la stessa struttura(
35
entre .uesti no(
*upponen$o che T1 e T2 a""iano lo stesso nuero n $i no$i, $eterinare il costo $ell'algorito proposto nel
caso peggiore e nel caso iglioreD $escrivere un esepio in cui si veri0ica il caso peggiore e uno in cui si
veri0ica il caso igliore.
Soluzione. Bna possi"ile soluzione la seguente(
algoritmo )+&))A)+'U++U'A( nodo +1/ nodo +2 ) #ool
if ( +1 $$ nBll ?? +2 $$ nBll ) then
return trBe!
else
// se sia#o +ui' aora uno tra T1 e T2 ( %uoto' oppure nessuno dei due ( %uoto
if ( +1 $$ nBll SS +2 $$ nBll ) then
return @alAe! // uno dei due ( %uoto e !atro no
else
return )+&))A)+'U++U'A( +1.le@t/ +2.le@t ) ?? )+&))A)+'U++U'A( +1.right/ +2.right )!
endif
endif
*e T1 e T2 sono entra"i vuoti, allora hanno la stessa struttura e l'algorito ritorna true. *e .uesto non
vero, signi0ica che T1 e T2 non sono entra"i vuoti, ossia uno tra essi vuoto, oppure nessuno $ei $ue lo .
*e uno $ei $ue vuoto e l'altro no, allora i $ue al"eri non hanno la stessa struttura. *e entra"i non sono
vuoti, allora T1 e T2 hanno la stessa struttura se e solo se i sottoal"eri sinistri e .uelli $estri hanno
rispettivaente la stessa struttura.
%l costo coputazionale $ell'algorito puN essere calcolato coe segue. *upponiao che entra"i gli al"eri
a""iano n no$i. %l caso peggiore per l'algorito si veri0ica .uan$o T1 e T2 hanno la stessa strutturaD in tal
caso l'algorito e00ettua sostanzialente una visita GsincronizzataH $i entra"i, con un costo $i R/n4.
%l costo nel caso ottio un po' pi- $elicato $a in$ivi$uare, e richie$e alcune ipotesi. 9ella aggior parte
$ei linguaggi $i prograazione /incluso Fava4, la valutazione $egli operatori "ooleani viene 0atta in
aniera GottiizzataH, nel senso che l'espressione , bb ' viene valutata coe segue(
if (> $$ @alAe) then
return @alAe!
else
return 9!
?ale o$o $i proce$ere $etto s)ort:circuit e!aluation o anche ;c<art)# e!aluation. Questo eccaniso
ha iplicazioni pratiche olto iportanti, al $i lC $i .uestioni $i e00icienza. !$ esepio, se l'espressione
seguente non 0osse valutata usan$o la short#circuit evaluation(
if ( a K 0 ?? b/a 1 0 ) then
// *ai +uacosa
endif
3> Capitolo 2( *trutture 1ati ;leentari 63MM!
si otterre""e un errore $i $ivisione per zero nel caso in cui a $$ 0 /se la short#circuit evaluation non viene
applicata, allora entra"i i lati $ell'Han$H logico verre""ero sepre e coun.ue valutati, e nel caso in cui a
$$ 0 l'espressione b/a causa un errore4.
*e gli al"eri hanno ciascuno n no$i, e le struttura seguenti(
$ove T1' ha /n#14 no$i, e T2' ne ha /n#24, allora la chiaata )+&))A)+'U++U'A( +1/ +2 ) esegue l'istruzione(
return )+&))A)+'U++U'A( +1.le@t/ +2.le@t ) ?? )+&))A)+'U++U'A( +1.right/ +2.right )!
che richie$e $i valutare innanzitutto il valore $i )+&))A)+'U++U'A( +1.le@t/ +2.le@t ) che restituirC
ie$iataente false. Quin$i, assuen$o che si stia applican$o la short#circuit evaluation, non sarC
necessario valutare )+&))A)+'U++U'A( +1.right/ +2.right ) , perchO il valore $ell'argoento $ell'istruzione return
giC calcolato coe false. Quin$i in .uesto caso l'algorito terina $opo 3/14 passi.
Esercizio 2.2$
Consi$eriao un al"ero "inario T e $ue suoi no$i u e !. *i $e0inisce =o>er <ommon Ancestor /,C!4 $ei
no$i u e !, in$icato con 2;A/u, !4, il no$o $i T $i pro0on$itC assia che ha sia u che ! coe $iscen$enti.
!$ esepio, nel caso seguente il ,C! $i u e ! il no$o ?(
9el caso uno $ei $ue sia antenato $ell'altro, allora anche il ,C! $i entra"i.
*crivere un algorito e00iciente che, $ato in input l'al"ero T e $ue no$i u e !, restituisce il ,C! $i u e !.
1eterinare il costo asintotico $ell'algorito proposto.
Soluzione. &roponiao un algorito che opera utilizzan$o $ue stac7 -u e -!. %n ciascuno stac7 verranno
inseriti i no$i presenti sul caino $a u e !, rispettivaente, 0ino alla ra$ice. !l terine $i .uesta
operazione, in cia a entra"i gli stac7 si troverC necessariaente un ri0eriento alla ra$ice $ell'al"ero.
;straiao conteporaneaente un eleento $a entra"i gli stac7D l'ultio eleento uguale estratto $a
entra"i sarC il ,C!. 3ccorre prestare attenzione al 0atto che, $urante .uesto processo, uno $ei $ue stac7
T1U T2U
T1 T2
9
u
%
38
potre""e svuotarsi /in particolare ciN acca$e se uno $ei $ue no$i antenato $ell'altro, e .uin$i esso stesso il
,C! $i entra"i4.
algoritmo 2;A(nodo B/ nodo J) nodo
Stac* )B!
Stac* )J!
do
)B.>U)=(B)!
B :$ B.parent!
)hile ( B K nBll )!
do
)J.>U)=(J)!
J :$ J.parent!
)hile ( J K nBll )!
nodo 2;A!
)hile( V)B.:)&M>+C() ?? V)J.:)&M>+C() ?? )B.+*>() $$ )J.+*>() ) .o
2;A :$ )B.+*>()!
)B.>*>()!
)J.>*>()!
end)hile
return 2;A!
%l costo $ell'algorito $oinato $al costo necessario per riepire gli stac7, che nel caso peggiore
corrispon$e alla pro0on$itC assia $ell'al"ero. &oichO nel caso peggiore un al"ero $i n no$i ha pro0on$itC
n#1 /l'al"ero $egenera in una catena4, si ha che il costo $ell'algorito nel caso pessio 3/ n4. %l caso
igliore si veri0ica .uan$o uno $ei $ue no$i la ra$ice e l'altro uno $ei suoi 0igliD in .uesto caso il costo
sarC 3/14.
Esercizio 2.2%
;' $ato un array AS1..nT coposto $a n nueri reali ar"itrari $iversi $a zero. ]ogliao calcolare un secon$o
array $S1..nT, in cui $SiT I AS1T X AS2T X W X ASnT ) ASiT. *crivere un algorito $i costo 3/n4 per calcolare
tutti i valori $ell'array $S1..nT, senza e00ettuare $ivisioni e utilizzan$o spazio aggiuntivo 3/14. /'uesto
eserci@io * stato (ro(osto da Aoogle durante i collo8ui di assun@ione4.
Soluzione. 9otiao innanzitutto che sepli0ican$o l'espressione $el valore $i $SiT, si ha che $SiT
corrispon$e al pro$otto $i tutti gli eleenti $i A tranne ASiT
%niziao esainan$o una soluzione che richie$e tepo 3/n4 e spazio aggiuntivo 3/n4D ve$reo poi coe
ri$urre il consuo $i eoria.
1e0iniao $ue array ,S1..nT e -S1..nT. ,SiT contiene il pro$otto $ei valori $el sottovettore AS1..i#1TD ,S1T vale
1. -SiT contiene il pro$otto $ei valori $el sottovettore ASiE1..nTD -SnT vale 1. Bna volta che i valori $i ,S1..nT e
-S1..nT sono stati calcolati, si ha che $SiT (I ,SiT X -SiT. %l calcolo $ei valori ,SiT e -SiT si puN e00ettuare in
tepo coplessivo 3/n4.
algoritmo W&++*'&6( arra" A,1..n- .i dou#le ) arra",1..n- .i dou#le
arra" >,1..n- .i dou#le!
arra" ),1..n- .i dou#le!
6,i-
>,i- ),i- A,1..n-
6,1..n-
3A Capitolo 2( *trutture 1ati ;leentari 63MM!
arra" 6,1..n- .i dou#le!
>,1- :$ 1!
for i :$ 2 to n do
>,i- :$ >,i"1- # A,i"1-!
endfor
),n- :$ 1!
for i :$ n"1 do)nto 1 do
),i- :$ ),i%1- # A,i%1-!
endfor
for i :$ 1 to n do
6,i- :$ >,i- # ),i-!
endfor
return 6!
,a soluzione prece$ente ha lo svantaggio $i richie$ere spazio aggiuntivo /n4. %n realtC possiao 0are a
eno $egli array , e -, usan$o al loro posto $ue varia"ili reali , e - nel o$o seguente(
algoritmo W&++*'&6( arra" A,1..n- .i dou#le ) arra",1..n- .i dou#le
dou#le >/ )!
arra" 6,1..n- .i dou#le!
> :$ 1!
6,1- :$ 1!
for i :$ 2 to n do
> :$ > # A,i"1-!
6,i- :$ >!
endfor
) :$ 1!
for i :$ n"1 do)nto 1 do
) :$ ) # A,i%1-!
6,i- :$ 6,i- # )!
endfor
return 6!
Esercizio 2.2&
*i consi$eri una stringa eorizzata in un array -S1..nT $i n K 1 caratteri. ,a stringa - si $ice palin$roa se
uguale alla sua versione letta a rovescio. !$ esepio, l'array S'6', '!', '9', '!', '6'T rappresenta una stringa
palin$roa, entre S'!', '9', 9', '%'T no. &er controllare se una stringa -S1..nT palin$roa su00iciente
veri0icare che il prio carattere risulti uguale all'ultio, il secon$o uguale al penultio e cosa via.
*crivere un algorito ricorsivo che, $ato in input un array $i caratteri -S1..nT, restituisce true se e solo se la
stringa * palin$roa. *crivere l'e.uazione $i ricorrenza per il tepo $i esecuzione T/n4 $ell'algorito in
0unzione $i n.
Soluzione. 1e0iniao l'algorito >A2:ND'*MA()/ i/ 0) che restituisce true se e solo se la stringa -Si..cT
palin$roa. Bna stringa palin$roa se coposta $a al pi- un singolo carattere, oppure se valgono
entra"e le con$izioni seguenti(
1. il prio carattere uguale all'ultio /-SiT I -SjT4, e
2. la stringa -SiE1,..j#1T ottenuta ignoran$o il prio e l'ultio carattere $i -Si..jT essa stessa
palin$roa.
algoritmo >A2:ND'*MA(arra" ),1..n- .i char/ int i/ int 0) #ool
if ( i X 0 ) then
return trBe!
else
return ( ),i- $$ ),0- ) ?? >A2:ND'*MA()/ i%1/ 0"1)!
endif
3:
,'algorito viene invocato con >A2:ND'*MA()/ 1/ n). 3sserviao che la ricorsione avviene su una sottostringa
che ha $ue caratteri in eno $ella stringa $i partenzaD il costo coputazionale $ell'algorito >A2:ND'*MA
.uin$i $ato $alla relazione $i ricorrenza seguente(
T (n)=
{
c
1
se n1
T (n2)+c
2
altrienti
Me$iante il eto$o $ella sostituzione si puN veri0icare che la soluzione T/n4 I 3/n4.
Esercizio 2.2'
*crivere un algorito che $ate in input $ue stringhe $i lunghezza n rappresentate e$iante $ue array $i
caratteri AS1..nT e $S1..nT, restituisce true se e solo se le $ue stringhe sono una l'anagraa $ell'altra. %n altre
parole, l'algorito $eve restituire true se e solo se entra"e le stringhe contengono gli stessi caratteri,
eventualente in or$ine $i00erente. !$ esepio, A I S'"', 'a', 'r', 'c', 'a'T e $ I S'c', 'r', 'a', '"', 'a'T sono
anagrai. entre A I S's', 'o', 'l', 'e'T e $ I S'e', 'l', 's', 'a'T non lo sono. Calcolare il costo coputazionale
$ell'algorito proposto.
Soluzione. %niziao proponen$o una soluzione non e00iciente a corretta, che si "asa sul o$o in cui
potreo operare per veri0icare anualente. ,'i$ea consiste nell'esainare uno per uno i caratteri $i A,
veri0ican$o che siano presenti anche in $. ]isto che ogni carattere puN coparire in A pi- volte, necessario
tener conto $i .uali caratteri $i $ sono giC stati GconsuatiH, in o$o $a evitare $i consi$erarli pi- $i una
volta. !llo scopo usiao un array $i "ooleani flagS1..nTD flagSjT I 1 se e solo se il j#esio carattere $i $ giC
stato consi$erato. 1urante la 0ase $i ricerca, gli eleenti $i $ i cui 0lag sono settati a true $evono essere
saltati.
algoritmo ANA('AMM:(arra" A,1..n- .i char/ arra" 6,1..n- .i char) #ool
arra" @lag,1..n- .i #ool!
// Ini$iai$$a$ione de!arra" *a).1//n1 a *ase
for i :$ 1 to n do
@lag,i- :$ @alAe!
endfor
for i :$ 1 to n do
// cerc7ia#o i carattere A.i1 in B
int 0 :$ 1!
)hile ( 0 3 n ?? (A,i- K 6,0- SS @lag,0- $ trBe) ) do
0 :$ 0 % 1!
end)hile
if ( 0 1 n ) then
return @alAe! // I carattere A.i1 non esiste in B
else
@lag,0- :$ trBe! // i carattere A.i1 esiste in B aa posi$ione :
endif
endfor
return trBe!
%l costo $ell'algorito 3/n
2
4 nel caso peggiore, e /n4 nel caso igliore, che si veri0ica .uan$o il prio
carattere $i A non presente in $.
;siste perN una soluzione pi- e00iciente che si "asa sull'i$ea seguente( $ue stringhe sono una l'anagraa
$ell'altra se e solo se, or$inan$o i caratteri, esse risultano uguali. !$ esepio, consi$eran$o le stringhe
'"arca' e 'cra"a', or$inan$o i caratteri otteniao in entra"i i casi 'aa"cr', $a cui possiao conclu$ere che
sono una l'anagrraa $ell'altro.
Stringa originale Stringa ordinata
bar8a aab8r
40 Capitolo 2( *trutture 1ati ;leentari 63MM!
8raba aab8r
3r$inare i caratteri $i ciascuna $elle $ue stringhe richie$e tepo 3/n log n4 usan$o un algorito $i
or$inaento genericoD in realtC, possi"ile ipiegare un algorito $i or$inaento in tepo lineare, $ato
che i caratteri al0a"etici sono in nuero 0inito. %l successivo controllo $ell'uguaglianza $elle versioni or$inate
richie$e tepo 3/n4.
Esercizio 2.3(
1ato un array AS1..nT e un intero 0 L k Q n, una k#rotazione a sinistra $i A il vettore ASkE1T. ASkE2T, W
ASnT, AS1T, AS2T, W ASkT ottenuto spostan$o a sinistra i suoi eleenti $i k posizioni, e reinseren$o ciascuno
$i essi alla 0ine. !$ esepio, una 3#rotazione a sinistra $el'array !6C1;2@= pro$uce l'array 1;2@=!6C.
&roporre un algorito per ruotare un array in tepo /n4 usan$o spazio ulteriore 3/14.
Soluzione. ,a soluzione pi- seplice s0rutta un array teporaneo tmp in cui copiare i valori $i A nelle
posizioni opportune.
'U*+A):N:)+'A( arra" A,1..n- .i dou#le/ int 4 )
arra" tmp,1..n- .i dou#le!
int i!
for i :$ 4 % 1 to n do
tmp,i " 4- :$ A,i-!
endfor
for i :$ 1 to 4 do
tmp,n 7 4 % i- :$ A,i-!
endfor
A :$ tmp! // copia t#p in A
,'algorito richie$e spazio /n4( Bna soluzione olto elegante /a tutt'altro che ovvia4 per ruotare un array
usan$o spazio 3/14 si "asa sulla seguente osservazione. *upponiao che B sia il sottovettore coposto $ai
prii k eleenti $i A, e C il sottovettore coposto $agli eleenti rianenti. <isulta .uin$i A I BC.
!pplichiao ora una 0unzione s'ap ai $ue sottovettori B e CD la 0unzione s'ap non 0a altro che GrovesciareH
ciascuno $ei $ue sottovettori sca"ia il prio eleento con l'ultio, il secon$o con il penultio e cosa via.
%n .uesto o$o otteniao il vettore B
D
C
D
. <ovesciao nuovaente l'intero array ottenen$o /B
D
C
D
4
D
I CB,
che esattaente il risultato cercato.
%l nuovo algorito 'U*+A):N:)+'A si "asa su una 0unzione )YA>/A, i% j4 che rovescia il sottovettore ASi..jT.
)YA>( arra" A,1..n- .i dou#le/ int i/ int 0 )
)hile ( i I 0 ) do
real tmp :$ A,i-!
A,i- :$ A,0-!
A,0- :$ tmp!
i :$ i % 1!
0 :$ 0 % 1!
end)hile
'U*+A):N:)+'A( arra" A,1..n- .i dou#le/ int 4 )
)YA>( A/ 1/ 4 )!
)YA>( A/ 4 % 1/ n )!
)YA>( A/ 1/ n )!
,'algorito cosa ottenuto ha costo /n4 e richie$e spazio ulteriore 3/14 coe richiesto $all'esercizio.
41
Esercizio 2.31
Bna $elle operazioni pi- couni nei so0t'are $i ela"orazione $elle iagini la possi"ilitC $i ruotare una
iagine $i :0 gra$i. *upponiao che l'iagine sia co$i0icata in una atrice .ua$rata ;S1..n, 1..nT $i
nueri interiD scrivere un algorito per ruotare i valori $ella atrice ; $i :0 gra$i in senso orario. !$
esepio, la atrice
$eve $iventare
<iuscite a risolvere il pro"lea usan$o pazio aggiuntivo 3/14U
Soluzione. ,a soluzione pi- seplice richie$e spazio aggiuntivo /n
2
4 per eorizzare una atrice
teporanea DS1..n, 1..nT che alla 0ine conterrC il risultato. ,'algorito <uotaMatrice copia la pria riga $i ;
nell'ultia colonna $i D, la secon$a riga $i ; nella penultia colonna $i D e cosa via. %n generale, la riga i#
esia $i ; viene copiata nella colonna /n E 1 V i4#esia $i D.
'U*+AMA+':;&( arra" M,1..n/ 1..n- .i int )
arra" ',1..n/ 1..n- .i int!
for i :$ 1 to n do
for 0 :$ 1 to n do
', 0/ n % 1 7 i - :$ M,i/ 0-!
endfor
endfor
M :$ '! // copia 4 in ;
%l costo asintotico $ell'algorito /n
2
4, in .uanto il corpo $el ciclo G0orH pi- interno viene eseguito
coplessivaente n
2
volte.
&er ri$urre lo spazio richiesto necessario e00ettuare la rotazione sca"ian$o $irettaente gli eleenti $ella
atrice ; secon$o lo schea seguente(
(
A $ <
E F /
A G H
)
(
A E A
G F $
H / <
)
42 Capitolo 2( *trutture 1ati ;leentari 63MM!
2oralente, l'eleento in posizione /i, j4 $eve essere spostato nella nuova posizione /j, n E 1 # i4D tale
operazione $eve essere ripetuta .uattro volte, in o$o che al terine l'ultio eleento va$a a$ occupare il
posto lasciato li"ero $al prio. 9ello pseu$oco$ice 0acciao uso $elle varia"ili 8Bri, 8Br0 per in$icare le
coor$inate $ell'eleento corrente, e neLti, neLt0 per in$icare le coor$inate $ell'eleento successivo nella
catena $i sca"i. 8BrJal $enota il valore che $ovrC essere scritto nella cella $i posizione /neLti, neLt04, entre
neLtJal contiene una copia $el vecchio valore presente in tale cella. si noti che necessario salvare il
contenuto $i ;SneLti, neLt0T pria $i sovrascriverlo con curval, in o$o $a poterlo a sua volta copiare nella
cella successiva.
'U*+AMA+':;&( arra" M,1..n/ 1..n- .i int )
for i :$ 1 to F2**'(n / 2) do
for 0 :$ i to n " i do
int 8Bri :$ i/ 8Br0 :$ 0/ neLti/ neLt0+ 8BrJal :$ M,i/ 0-!
for 4 :$ 1 to 4 do
neLti :$ 8Br0!
neLt0 :$ n % 1 " 8Bri!
int neLtJal :$ M,neLti/ neLt0-!
M,neLti/ neLt0- :$ 8BrJal!
8BrJal :$ neLtJal!
8Bri :$ neLti!
8Br0 :$ neLt0!
endfor
endfor
endfor
Esercizio 2.32
*crivere un algorito e00iciente che, $ato in input una lista singolarente concatenata /ogni no$o contiene
un ri0eriento all'eleento successivo a non al prece$ente4, restituisce un ri0eriento al k#esio eleento
a partire $alla 0ine. !$ esepio, se k I 1 l'algorito $eve restituire un ri0eriento all'ultio eleentoD se
k I 2 al penultio, e cosa via. ,'algorito $ovre""e e00ettuare una singola scansioni $ella lista, e utilizzare
spazio aggiuntivo 3/14.
Soluzione. ,a pria soluzione che pro"a"ilente viene in ente consiste nell'e00ettuare $ue scansioni $ella
lista( la pria per contare il nuero n $i eleenti presenti, e la secon$a per acce$ere all'eleento in
posizione n E 1# k. Con un po' $i astuzia perN possi"ile risolvere il pro"lea con una singola scansione.
,'i$ea consiste nello scorrere la lista utilizzan$o $ue cursori, che chiaiao laAt1 e laAt4. 1urante la
scansione anteniao la proprietC che il cursore laAt4 punti all'eleento che si trova k posizioni pi- in$ietro
(8Bri/ 8Br0)
(neLti/ neLt0)
8BrJal
neLtJal
43
rispetto al cursore laAt1. % $ue cursori vengono 0atti avanzare conteporaneaente 0ino a .uan$o laAt1
$iventerC uguale a 9B,,, aven$o .uin$i raggiunto la 0ine $ella lista. ! .uesto punto il secon$o cursore
conterrC il ri0eriento all'eleento $esi$erato.
2:)+A<U2+:M*( ,ist 2/ int 4 ) ,ist
,ist laAt1 :$ 2+ laAt4 :$ 2!
int i :$ 0!
)hile ( laAt1 K NU22 and i I 4 ) do
laAt1 :$ laAt1.neLt!
i :$ i % 1!
end)hile
if ( i I 4 ) then
errore N8i Aono meno .i 4 elementi nella liAtaP
endif
)hile ( laAt1 K NU22 ) then
laAt1 :$ laAt1.neLt!
laAt4 :$ laAt4.neLt!
end)hile
return laAt4!
Capitolo 3: -rdinamento e
.icerca
Esercizio 3.1
Consi$erare la seguente variante $ell'algorito )&2&;+:*N)*'+(
algoritmo M:*)&2&;+:*N)*'+( arra" A,1..n- .i dou#le )
for 4 :$ 1 to n"1 do
int m :$ 4!
for 0 :$ 4%1 to n do
if ( A,0- 3 A,m- ) then
m :$ 0!
endif
endfor
// sca#&ia A.01 con A.#1<
dou#le tmp :$ A,4-!
A,4- :$ A,m-!
A,m- :$ tmp!
endfor
<icor$iao che un algorito $i or$inaento stabile se preserva l'or$inaento relativo $egli eleenti
uguali presenti nell'array $a or$inare.
,'algorito M:*)&2&;+:*N)*'+ un algorito $i or$inaento sta"ileU %n caso negativo, ostrare coe
o$i0icarlo per 0arlo $iventare sta"ile. Motivare le risposte.
Soluzione. ,'algorito M:*)&2&;+:*N)*'+ .uasi i$entico all'algorito )&2&;+:*N)*'+ $escritto nel li"ro $i
testo, con la $i00erenza che la con$izione stata scritta coe Gi@ ( A,:- 3 A,#- )H /cio usan$o l'operatore
inore o uguale4. Questo 0a sa che M:*)&2&;+:*N)*'+ non sia un algorito $i or$inaento sta"ile, perchO in
caso $i eleenti uguali ette in pria posizione l'ultio eleento trovato. &er ren$erlo sta"ile su00iciente
riscrivere l'i0 coe Gi@ ( A,:- I A,#- )H
Esercizio 3.2
1ato un array AS1..nT $i nK3 eleenti con0ronta"ili, tutti $istinti, $escrivere un algorito che in tepo 3/14
$eterina un eleento .ualsiasi $ell'array che non sia nO il inio nO il assio.
! cosa puN servire un algorito $el genereU 3vvero, esiste .ualche pro"lea che a""iao a00rontato nel
corso la cui soluzione potre""e "ene0iciare $a .uesto algoritoU
Soluzione. &er risolvere il pro"lea "asta consi$erare i prii tre eleenti $i A, ossia AS1T, AS2T e AS3T. *i
cercano il assio e il inio tra .uesti tre, e si restituisce .uello tra $i loro che non nO assio nO
inio. Bn tale eleento esiste sepre, perchO per ipotesi tutti gli eleenti sono $istinti.
algoritmo N&M:NN&MAQ( arra" A,1..n- .i elem ) elem
4> Capitolo 3( 3r$inaento e <icerca 63MM!
int min12! // %aore #ini#o tra A.11 e A.21
int maL12! // %aore #assi#o tra A.11 e A.21
if ( A,1- I A,2- ) then
min12 :$ A,1-!
maL12 :$ A,2-!
else
min12 :$ A,2-!
maL12 :$ A,1-!
endif
if ( A,3- I min12 ) then
return min12!
elseif ( A,3- I maL12 ) then
return A,3-!
else
return maL12!
endif
*i osservi che le varia"ili min12 e maL12 contengono rispettivaente il valore inio e assio tra AS1T e
AS2T.
Bn siile algorito puN essere utilizzato per scegliere il pivot /in o$o $eterinistico4 in o$o $a evitare il
caso pessio nell'algorito QU:;<)*'+ e QU:;<)&2&;+, assuen$o che tutti i valori in input siano $istinti.
Esercizio 3.3
Bn collezionista $i 0igurine vi ha incaricati $i risolvere il seguente pro"lea. %l collezionista possie$e I
0igurine, non necessariaente $istinte. ,e 0igurine vengono stapate con un nuero $i serie, ipresso $al
pro$uttore. % nueri $i serie sono tutti gli interi copresi tra 1 e J. ,a collezione sare""e copleta se ci
0osse aleno un eseplare $i tutte le J 0igurine pro$otte. &urtroppo la collezione non copleta( sono
presenti $ei $uplicati, entre alcune 0igurine ancano $el tutto. %l vostro copito $i in$icare i nueri $i
serie $elle 0igurine ancanti.
1. *crivere un algorito e00iciente che $ato J e l'array -S1..IT, ove -SiT il nuero $i serie $ella i#
esia 0igurina posse$uta, stapa l'elenco $ei nueri $i serie ancanti. ,'array - non or$inato. !$
esepio, se J=10 e *=S1, 4, 2, 8, 10, 2, 1, 4, 3T, l'algorito $eve stapare a vi$eo i nueri $i serie
ancanti 5, >, A, : /non necessariaente in .uesto or$ine4
2. 1eterinare il costo coputazionale $ell'algorito $i cui sopra, in 0unzione $i J e I" !ttenzione( I
potre""e essere inore, uguale o aggiore $i J.
Soluzione. *0ruttan$o il suggeriento, ipleentiao l'i$ea che segue( $e0iniao un array "ooleano
$S1..JT, inizialente con tutti gli eleenti posti a 0alse. &oniao poi $SkT I true se e solo se il collezionista
possie$e una 0igurina con nuero $i serie k. !l terine $ell'algorito, i valori $i k per cui $SkT I false
rappresentano i nueri $i serie $elle 0igurine ancanti. ,'algorito puN essere $escritto coe segue(
algoritmo ;&';AF:(U':N&MAN;AN+:( int N/ arra" ),1..<- .i int )
arra" 6,1..N- .i #ool
// (1) Ini$iai$$a !arra" B
for i :$ 1 to N do
6,i- :$ @alAe!
endfor
// (2) Controa i nu#eri di serie dee *i)urine possedute
for i :$ 1 to < do
6,),i-- :$ trBe!
endfor
// (=) Sta#pa i nu#eri di serie #ancanti
for i :$ 1 to N do
if ( 6,i- $$ @alAe ) then
print Nman8a il nBmero .i Aerie N i!
endif
endfor
48
!nalizziao il costo coputazionale $ell'algorito. %l prio ciclo ha costo /J4D il secon$o ha costo /I4D
il terzo ha costo /J4. %l costo coplessivo .uin$i /2JEI4 = /JEI4.
Esercizio 3.
*i consi$eri un array AS1..nT $i nueri reali, non necessariaente $istinti. *upponiao che esista un intero i,
1 i Q n tale che il sottovettore AS1..iT sia or$inato in senso crescente, entre il sottovettore ASiE1..nT sia
or$inato in senso $ecrescente.
1. 1escrivere un algorito e00iciente che, $ato in input l'array AS1..nT e il valore i, or$ina A in senso
crescente / possi"ile utilizzare un array teporaneo $urante la proce$ura $i or$inaento4.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. %l pro"lea si risolve con una seplice variazione $ella proce$ura M&'(& vista per l'algorito
M&'(&)*'+(
algoritmo *'D:NA6:+*N:;A( arra" A,1..n- .i dou#le/ int i ) arra"
arra" 6,1..n- .i dou#le!
int i1 :$ 1!
int i2 :$ n!
int 0 :$ 1! // indice in B
)hile ( i1 3 i ?? i2 1 i ) do
if ( A,i1- I A,i2- ) then
6,0- :$ A,i1-!
i1 :$ i1%1!
0 :$ 0%1!
else
6,0- :$ A,i2-!
i2 :$ i2"1!
0 :$ 0%1!
endif
end)hile
)hile ( i13i ) do
6,0- :$ A,i1-!
i1 :$ i1%1!
0 :$ 0%1!
end)hile
)hile ( i2 1 i ) do
6,0- :$ A,i2-!
i2 :$ i2"1!
0 :$ 0%1!
end)hile
return 6!
%l costo coputazionale $i tale algorito /n4
Esercizio 3.!
*i consi$eri il seguente algorito $i or$inaento, che viene inizialente invocato con la chiaata
AtoogeAort(2/ 1/ n)(.
algorithm )+**(&)*'+( arra" 2,1..n-/ int i/ int 0 )
if (0 X i) then
return!
endif
if (2,0- I 2,i-) then
A8ambia 2,i- 8on 2,0-!
endif
4A Capitolo 3( 3r$inaento e <icerca 63MM!
if ((0 " i) 1 1) then
int t $ (0 " i % 1)/3!
)+**(&)*'+(2/ i / 0"t)!
)t**(&)*'+(2/ i%t/ 0 )!
)+**(&)*'+(2/ i / 0"t)!
endif
1. 1escrivere a parole coe 0unziona l'algorito *+**(&)*'+
2. Calcolare il costo coputazionale asintotico $i *+**(&)*'+(2/ 1/ n) in 0unzione $i n
Soluzione. ,'algorito opera nel o$o seguente( $opo aver sisteato nell'or$ine corretto gli eleenti
iniziali e 0inale $ell'intervallo =Si..jT, e00ettua tre chiaate ricorsive. 9ella pria or$ina gli eleenti
appartenenti ai prii 2)3 $el sottovettore =Si..jTD nella secon$a or$ina gli eleenti appartenenti agli ultii 2)3
$el sottovettore /o$i0icato4 =Si..jTD in0ine nella terza chiaata e00ettua nuovaente l'or$inaento $egli
eleenti appartenenti ai prii 2)3 $el sottovettore /o$i0icato4 =Si..jT. Quin$i l'algorito e00ettua tre
chiaate ricorsive, ciascuna su un input che ha lunghezza pari a 2)3 .uella $ell'input originale.
,'e.uazione $i ricorrenza associata la seguente(
T (n)=
{
c
1
se n2
3T
(
2
3
n
)
+c
2
altrienti
! .uesto punto si puN applicare il caso 14 $el Master ?heore, con aI3, bI3)2 /attenzione, 939 bI2)34,
ottenen$o
T (n)=(n
log
b
a
)(n
2.80:5
)
$a cui si $e$uce che .uesto algorito $i or$inaento non olto e00iciente.
Esercizio 3.$
*i consi$eri un array AS1..nT, non vuoto, contenente tutti gli interi appartenenti all'insiee [1, 2, W, nE1\,
tranne uno. ,'array A or$inato in senso crescente.
1. *crivere un algorito e00iciente che, $ato l'array AS1..nT, $eterina il valore ancante. !$ eseipo,
se AIS1, 2, 3, 4, >, 8T, l'algorito $eve restituire il valore 5.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Bna soluzione non e00iciente consiste nell'esainare il vettore A $all'inizioD non appena si
incontra il prio valore i tale che ASiT d i, si puN conclu$ere che il valore ancante i. ,o pseu$oco$ice il
seguente(
algoritmo +'*WAWA2*'&MAN;AN+&( arra" A,1..n- .i int ) int
for i:$1 to n do
if ( A,i- V$ i ) then
return i!
endif
endfor
// Se sia#o arri%ati +ui' si)ni*ica c7e i %aore #ancante ( n>1
return n%1!
%l costo $ell'algorito +'*WAWA2*'&MAN;AN+&1 3/n4D in particolare, risulta /n4 nel caso pessio /che si
veri0ica .uan$o il valore ancante nE14 e 3/14 nel caso oggio /che si veri0ica .uan$o il valore ancante
14.
*0ruttan$o il 0atto che l'array or$inato, possiao $e0inire una soluzione pi- e00iciente seguen$o il
suggeriento $i utilizzare una variante $ella ricerca "inaria. ,'i$ea la seguente( si in$ivi$ua la posizione
4:
centrale m nel sottovettore ASi..jT. *e ASmT contiene il valore m, allora sicuraente non ci sono eleenti
ancanti nella pria etC $el sottovettore, e la ricerca continua in ASmE1..jT. %nvece, se ASmT d m, la ricerca
prosegue nella pria etC ASi..m#1T. *i noti che in .uest'ultio caso il valore ancante potre""e essere m.
,'aspetto cruciale $i .uesto algorito la gestione $el caso "ase $ella ricorsione( se i J j possiao
conclu$ere che il valore ancante jE1.
algoritmo +'*WAWA2*'&MAN;AN+&( arra" A,1..n- .i int/ int i/ int 0 ) int
if ( i 1 0 ) then
return i!
else
int m :$ ( i % 0 ) / 2!
if ( A,m- $$ m ) then
return +'*WAWA2*'&MAN;AN+&(A/ m % 1/ 0)!
else
return +'*WAWA2*'&MAN;AN+&(A/ i/ m " 1)!
endif
endif
,a precon$izione $i .uesto algorito, cio la proprietC $i cui $evono go$ere i paraetri $i input, la
seguente(
A[ k]=k per ogni k=1, ... i1
A[ k ]=k +1 per ogni k=j +1, ... n
%n altre parole, .uan$o la 0unzione viene invocata, tutti gli eleenti ASkT che si trovano Ga sinistraH $ella
posizione i $evono essere tali che ASkT I kD invece, tutti gli eleenti ASmT che si trovano Ga $estraH $ella
posizione j $evono essere tali che ASkT I kE1. Questa consi$erazione ci aiuta a $e0inire cosa $eve restituire
l'algorito nel caso "aso, cio .uan$o i J j. *e i I jE1 possiao riscrivere la precon$izione coe(
A[ k]=k per ogni k=1, ... i1
A[ k ]=k +1 per ogni k=i % ... n
$a cui risulta ie$iataente che il valore ancante i.
,'algorito viene invocato con +'*WAWA2*'&MAN;AN+&(A/ 1/ n)D il costo coputazionale 3/log n4,
esattaente coe per la ricerca "inaria.
Esercizio 3.%
*i consi$eri un array AS1..nT $i interi in cui ciascun valore puN essere esclusivaente 0 oppure 1. % valori
sono presenti senza alcun or$ineD anche possi"ile che tutti i valori siano uguali.
1. *crivere un algorito avente coplessitC ottia che or$ini l'array A spostan$o tutti i valori 0 pria
$i tutti i valori 1. ]errC assegnato punteggio pieno a$ algoriti che sca"iano eleenti in A, che
richie$ono eoria ulteriore 3/14 /.uin$i che non s0ruttano array ausiliari4, e che non sono "asati
sul conteggio $el nuero $i 0 e 1 presenti.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Questo pro"lea una versione pi- seplice $el pro"lea $ella G"an$iera nazionaleH $escritto
nell';sercizio 3.12. *0ruttiao $ue cursori i e j, tali che i si sposta $al prio eleento $el vettore A e avanza
verso la co$a, entre j si sposta $all'ultio eleento $i A e avanza verso la testa. %l nostro algorito esegue
un ciclo increentan$o ripetutaente i e)o $ecreentan$o j. 1urante il ciclo, anterreo la proprietC che il
sottovettore AS1..i#1T coposto $a tutti valori 0, il sottovettore ASjE1..nT coposto $a tutti valore 1,
entre il sottovettore rianente ASi..jT puN contenere sia zeri che uni.
50 Capitolo 3( 3r$inaento e <icerca 63MM!
!$ ogni iterazione, esainiao $appria ASiT. *e vale 0, si trova giC $alla parte GgiustaH $el vettore e
possiao increentare i passan$o alla prossia iterazione. *e ASiT vale 1, allora esainiao ASjTD se
.uest'ultio vale 1, allora si trova giC $alla parte GgiustaH $el vettore e $ecreentiao j passan$o alla
prossia iterazione. *e le con$izioni prece$enti sono entra"e 0alse signi0ica che ASiT II 1 e ASjT II 0. %n
tal caso i valori si trovano $alla parte Gs"agliataH $el vettore, a possiao ripristinarli nelle posizioni
corrette sca"ian$oli tra loro. 1opo aver e00ettuato lo sca"io avreo ASiT II 0 e ASjT II 1, al che potreo
increentare i e $ecreentare j passan$o all'iterazione successiva.
algoritmo *'D:NA01( arra" A,1..n- .i int )
int i :$ 1!
int 0 :$ n!
)hile ( i I 0 ) do
if ( A,i- $$ 0 ) then
i :$ i%1!
elseif ( A,0- $$ 1 ) then
0 :$ 0"1!
else // A.i1 ?? 1 e A.:1 ?? @< sca#&ia#o tra oro A.i1 e A.:1 per ripristinare !ordine
int tmp :$ A,i-!
A,i- :$ A,0-!
A,0- :$ tmp!
i :$ i % 1!
0 :$ 0 " 1!
endif
end)hile
!nalizziao passo $opo passo il coportaento $ell'algorito su .uesto seplice esepio(
&oichO ASiT II 0, increentiao i
!""iao che ASiT II 1 e ASjT II 0( sca"iao ASiT e ASjT, e 0acciao avanzare entra"i i cursori verso il
centro
0
i :
0 0 1 1 1 1
0 1 1 1 0 1 0 1 0
i :
0 1 1 1 0 1 0 1 0
i :
51
&oichO ASjT II 1, $ecreentiao j
ASjT II 1, $ecreentiao j
ASiT II 1 e ASjT II 0, sca"iao ASiT e ASjT e 0acciao avanzare entra"i i cursori verso il centro
ASiT II 0, increentiao iD a .uesto punto iIIj, e l'algorito terina.
&er calcolare il costo coputazionale, osserviao che a$ ogni iterazione necessariaente increentiao i
oppure $ecreentiao j /o entra"i4. Quin$i $opo /n4 iterazioni i $ue cursori i e j si incroceranno e
l'algorito terina.
Esercizio 3.&
*i consi$erino $ue array AS1..nT e $S1..mT, contenenti n e$ m valori interi, rispettivaente. ;ntra"i gli array
sono or$inati in senso crescente, e ciascuno $ei $ue contiene eleenti $istinti. Z perN possi"ile che lo stesso
valore sia presente sia in A che in $.
1. *crivere un algorito $i coplessitC ottia per stapare i valori $i A che non sono presenti in $. !$
esepio, se AIS1, 3, 4, 8, AT e $IS2, 3, 5, 8T, l'algorito $eve stapare 1, 4, A /in0atti i rianenti
valori $i A, 3 e 8, sono presenti anche in $ .uin$i 939 $evono essere stapati4.
2. !nalizzare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Z possi"ile risolvere il pro"lea e00ettuan$o una singola scansione $ei $ue array, s0ruttan$o il
0atto che entra"i sono or$inati. %n particolare, usiao $ue cursori i e j per scorrere A e $, rispettivaente.
!$ ogni iterazione con0rontiao ASiT e $SjT. *e ASiT Q $SjT, sicuraente ASiT non copare in $ e puN .uin$i
essere stapatoD 0acciao .uin$i avanzare i. *e ASiT J $SjT, 0acciao avanzare j e non stapiao ASiT
/in0atti non siao sicuri che il valore ASiT non coparirC nei prossii eleenti $i $4. %n0ine, se ASiT uguale
a $SjT, 0acciao avanzare entra"i i cursori e non stapiao nulla. 3sserviao che, arrivan$o alla 0ine $el
vettore $, $o""iao ricor$arci $i stapare tutti gli eleenti resi$ui $i A"
0 1 0 1 0 1 1 1 0
i :
0 1 0 1 0 1 1 1 0
i :
0 1 0 1 0 1 1 1 0
i :
0 0 0 1 1 1 1 1 0
i :
52 Capitolo 3( 3r$inaento e <icerca 63MM!
algoritmo D:FF&'&NMA( arra" A,1..n- .i int/ arra" 6,1..m- .i int )
int i :$ 1!
int 0 :$ 1!
)hile ( i 3 n ?? 0 3 m ) do
if (A,i- I 6,0-) then
print A,i-!
i :$i % 1!
elseif (A,i- 1 6,0-) then
0 :$ 0 % 1!
else
i :$ i % 1!
0 :$ 0 % 1!
endif
end)hile
)hile ( i 3 n ) do
print A,i-!
i :$ i % 1!
end)hile
!$ ogni passo, l'algorito avanza $i una posizione in A oppure in $ /oppure in entra"i i vettori4. Quin$i il
costo coputazionale O/nEm4, in .uanto possi"ile e00ettuare al pi- nEm iterazioni coplessivaente. Bn
esepio $i input in cui si veri0ica il caso peggiore il seguente(
A I S1, 3, 5, 8, :T
$ I S2, 4, >T
Esercizio 3.'
*i consi$eri un array AS1..nT non vuoto che contiene tutti gli interi nell'insiee [1, 2, W, nE2\, tranne $ue.
,'array non or$inato. ,'array A non contiene valori $uplicati.
1. *crivere un algorito $i coplessitC ottia in gra$o $i stapare i $ue nueri ancanti.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Bsiao una variante $ell'algorito counting sortD utilizziao un array ausilirio $S1..nE2T
inizializzato a 0alse, e settiao $S?T a true se il valore ? presente in A(
algoritmo )+AM>AMAN;AN+:( arra" A,1..n- .i int )
arra" 6,1..n%2- .i #ool!
for i :$ 1 to n%2 do
6,i- :$ @alAe! // B.i1 ? true indica c7e i nu#ero i ( presente in A
endfor
for i:$1 to n do
6,A,i-- :$ trBe!
endfor
for i :$ 1 to n%2 do
if ( 6,i- $$ @alAe ) then
print i!
endif
endfor
%l costo coputazionale /n4
Esercizio 3.1(
*i consi$eri un array AS1..nT $i n nueri reali $istinti e un intero k [1, W, n\D l'array non or$inato.
1. *crivere un algorito che, $ati A e k, restituisca o stapi i k valori pi- piccoli presenti in A. %l costo
$ell'algorito proposto $eve essere al pi- 3/kn4. *e ritenuto necessario, possi"ile 0are uso anche $i
0unzioni ausiliarie viste a lezione senza "isogno $i scriverne lo pseu$oco$ice.
53
2. Calcolare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. ;sistono $iverse soluzioni a .uesto pro"lea. Bna soluzione non olto e00iciente consiste
nell'utilizzare un algorito $i tipo )&2&;+:*N)*'+, o$i0icato per 0erarsi $opo aver or$inato i prii k
eleenti $i A. ,o pseu$oco$ice il seguente(
algoritmo >':M:<M:N1( arra" A,1..n- .i dou#le/ int 4 )
// Si assu#e A non %uoto' e 1A0An
for i :$ 1 to 4 do
int imin :$ i!
for 0 :$ i%1 to n do
if ( A,0- I A,imin- ) then
imin :$ 0!
endif
endfor
// sca#&ia A.i#in1 con A.i1
dou#le tmp :$ A,imin-!
A,imin- :$ A,i-!
A,i- :$ tmp!
print A,i-!
endfor
%l costo $ell'algorito R/nk4, che copati"ile con .uanto richiesto $all'esercizio. Bna soluzione $iversa e
leggerente pi- e00iciente consiste nel creare un in#heap a partire $all'array !, e$ estrarre k volte
l'eleento inio. ,o pseu$oco$ice il seguente /e ricor$a olto l'algorito heapselect visto a lezione4
algoritmo >':M:<M:N2( arra" A,1..n- .i dou#le/ int 4 )
M:N=&A>:FC(A)!
for i :$ 1 to 4 do
J :$ F:NDM:N(A)!
print J!
D&2&+&M:N(A)!
endfor
,'operazione M:N=&A>:FC(A) ha costo 3/n4, entre invocare k volte le operazioni F:NDM:N /$i costo 3/14 4 e
D&2&+&M:N /$i costo 3/log n4 4 ha un costo coplessivo $i 3/k log n4. %l costo totale risulta .uin$i essere
3/n E k log n4.
Esercizio 3.11
*crivere un algorito e00iciente che, $ato in input un array AS1..nT $i n K 1 nueri reali, peruta A in o$o
tale che tutti i valori negativi copaiano pria $i tutti i valori positivi. 9on richiesto che i valori positivi e
negativi siano a loro volta or$inati. !$ esepio, se AIS#3, 2, 4, >, #3, #4T, l'algorito puo' restituire, a$
esepio, il vettore S#3,#3,#4,2,4,>T oppure il vettore S#3,#4,#3,>,2,4T.
Esercizio 3.12
%l pro"lea seguente 0u inizialente proposto $a ;$sger e. 1ic7stra coe Eutc) Jational /lag ,roblemD ne
proponiao una rivisitazione in chiave italiana. *ia AS1..nT un array $i caratteri, i cui eleenti assuono
valori nell'insiee ['6', '<', ']'\ /G"iancoH, GrossoH e Gver$eH4. *crivere un algorito e00iciente che peruta
gli eleenti $i A in o$o tale che tutti i valori ']' prece$ano tutti i valori '6', i .uali a loro volta prece$ano
tutti i valori '<'. ,'algorito $ovre""e richie$ere spazio aggiuntivo 3/14, .uin$i $ovre""e liitarsi a
perutare tra loro gli eleenti $i A senza usare un secon$o array $i appoggio.
Soluzione. Btilizziao un algorito iterativo che esaina gli eleenti $i A e li sposta nella posizione
corretta. ,'algorito antiene tre cursori i, j, k che separano gli eleenti ']', '6' e '<' nel o$o seguente(
54 Capitolo 3( 3r$inaento e <icerca 63MM!
Quin$i AS1..i#1T rappresenta la parte ver$e, ASi..j#1T rappresenta la parte "ianca, ASkE1..nT rappresenta la
parte rossa e in0ine ASj..kT rappresenta la parte $el vettore ancora $a esplorare. %n altre parole, l'algorito
antiene le seguenti invarianti /ossia a$ ogni ciclo antiene vere le seguenti proprietC4(
ASmT I ']' per ogni mI1, W, i#1D
ASmT I '6' per ogni mIi, W, j#1D
ASmT I '<' per ogni mIkE1, W n
entre il contenuto $i ASj..kT inesplorato. ,'i$ea $ell'algorito consiste nell'esainare il valore ASjT e
spostarlo, se necessario, nella posizione corretta. 3ccorre .uin$i $e0inire in $ettaglio il coportaento
$ell'algorito in "ase al valore $i ASjT. *e ASjT I '6', si increenta j senza 0are nessuna ulteriore operazione,
in .uanto a""iao scoperto un eleento "ianco che si trova giC in co$a alla parte "ianca $el vettore. ,a
situazione ostrata nella 0igura seguente(
*e ASjT I ']', allora sca"iao tra $i loro gli eleenti ASiT e ASjT, in o$o $a spostare ASjT in co$a alla parte
ver$eD si increentano .uin$i i e j. ,a situazione ostrata nella 0igura seguente(
%n0ine, se ASjT I '<', si sca"iano tra $i loro gli eleenti ASjT e ASkT e si $ecreenta k. ,! situazione
ostrata nella 0igura seguente(
i : 0 1 n
i : 0 1 n
i : 0 1 n
i : 0 1 n
i : 0 1 n
55
*iao ora in gra$o $i 0ornire lo pseu$oco$ice copleto $ell'algorito $ella "an$iera(
algoritmo 6AND:&'A( arra" A,1..n- .i char )
int i :$ 1!
int 0 :$ 1!
int 4 :$ n!
char tmp! // usata co#e %aria&ie te#poranea per )i sca#&i
)hile ( 0 3 4 ) do
if ( A,0- $$ U6U ) then
0 :$ 0 % 1!
elseif ( A,0- $$ UWU ) then
tmp :$ A,0-!
A,0- :$ A,i-!
A,i- :$ tmp!
i :$ i % 1!
0 :$ 0 % 1!
else
tmp :$ A,4-!
A,4- :$ A,0-!
A,0- :$ tmp!
4 :$ 4 " 1!
endif
end)hile
&er calcolare il costo asintotico $ell'algorito, osserviao che a$ ogni iterazione la lunghezza $ella parte
inesplorata /rappresentata in grigio4 $iinuisce sepre $i un eleento. 3gni iterazione /il corpo $el ciclo
G'hileH4 ha costo 3/14. %nizialente la parte inesplorata coposta $a tutti gli n eleenti $el vettore.
Quin$i l'algorito terina in R/n4 passi.
Esercizio 3.13
*crivere una variante $ell'algorito M&'(&)*'+, che chiaereo M&'(&)*'+4( A,1..n-/ i/ 0 ), in cui il
/sotto#4vettore ASi..jT $a or$inare viene su$$iviso in .uattro parti anzichO in $ue. M&'(&)*'+4 $eve 0are uso
$ella 0unzione M&'(& usuale, che 0on$e $ue sottovettori or$inati contigui. &restare attenzione che sono
necessarie tre 0asi $i M&'(&( supponen$o che il ASi..jT venga su$$iviso in ASi..t1T, ASt1E1..t2T, ASt2E1..t3T e
ASt3E1..jT, $opo aver ricorsivaente or$inato ciascun sottovettore necessario e00ettuare $appria la 0usione
$i ASi..t1T e ASt1E1..t2T, .uin$i la 0usione $i ASt2E1..t3T e ASt3E1..jT e in0ine la 0usione $i ASi..t2T e ASt2E1..jT.
!nalizzare .uin$i il costo coputazionale $i M&'(&)*'+4.
Soluzione. <icor$iao che la chiaata M&'(&(A/ i/ 4/ 0) vista a lezione 0on$e i $ue sottovettori or$inati
contigui ASi..kT e ASkE1..jT. ,'algorito M&'(&)*'+4 puN essere $escritto $allo pseu$oco$ice seguente(
algoritmo M&'(&)*'+4( arra" A,1..n- .i dou#le/ int i/ int 0 )
i : 0 1 n
i : 0 1 n
5> Capitolo 3( 3r$inaento e <icerca 63MM!
i@ ( i X 0 ) then
return!
else
int t2 :$ (i % 0) / 2! // arrotondato per di*etto
int t1 :$ (i % t2) / 2! // arrotondato per di*etto
int t3 :$ (t2 % 0) / 2! // arrotondato per di*etto
M&'(&)*'+4( A/ i/ t1 )! // costo T(n/B)
M&'(&)*'+4( A/ t1%1/ t2 )! // costo T(n/B)
M&'(&)*'+4( A/ t2%1/ t3 )! // costo T(n/B)
M&'(&)*'+4( A/ t3%1/ 0 )! // costo T(n/B)
M&'(&( A/ i/ t1/ t2 )! // costo (n/2 = (n
M&'(&( A/ t2%1/ t3/ 0 )! // costo (n/2 = (n
M&'(&( A/ i/ t2/ 0 )! // costo (n
endif
,a parte pi- $elicata $ell'algorito consiste pro"a"ilente nel calcolare gli in$ici t1, t2, t3 che $eliitano le
.uattro partizioni $ell'array. *i potre""e essere tentati $i scrivere .ualcosa coe(
int t1 :$ (i % 0) / 4! // SBAGLIATO,
a .uesto sare""e errato. !$ esepio, se iI10, jI14, si avre""e t1I> il che ipossi"ile, in .uanto si $eve
sepre avere i L t1 L t2 L t3 L j. ,a soluzione proposta, invece, calcola pria la posizione e$iana t2 tra i e
j, e successivaente la posizione e$iana t1 tra i e t2, e la posizione e$iana t3 tra t2 e j. *i 0accia
ri0eriento alla 0igura seguente
,'analisi $el costo coputazionale si puN e00ettuare scriven$o l'e.uazione $i ricorrenza $el costo T/n4
necessario a$ or$inare un /sotto#4vettore con n eleenti. 3sserviao che ciascuna $elle .uattro chiaate
ricorsive a M&'(&)*'+4 ha costo T/n)44, in .uanto opera su un sottovettore che ha $iensioni circa un .uarto
$el sottovettore $i input. <icor$an$o che il costo $ell'operazione M&'(& proporzionale alla soa $elle
$iensioni $ei vettori $a 0on$ere, le prie $ue operazioni M&'(& hanno costo /n/24 I /n4, entre l'ultia
ha costo /n4. %n sostanza, il costo coplessivo $elle .uattro chiaate ricorsive 4 T/n)44, entre il costo
cuulativo $i tutte le operazioni merge /n4. &ossiao .uin$i scrivere(
T (n)=
{
c
1
se n1
4T (n/ 4)+c
2
n altrienti
che in "ase al Master ?heore /caso 2, con a I b I 4, f/n4 I c
2
n4 ha coe soluzione T/n4 I /n log n4.
&ossiao .uin$i conclu$ere che M&'(&)*'+4 ha esattaente lo stesso costo asintotico $i M&'(&)*'+.
Esercizio 3.1
Bna atrice .ua$rata ;S1..n, 1..nT $i nn interi un 8uadrato latino se ogni intero nell'insiee [1, W, n\
copare una e una sola volta in ogni riga e in ogni colonna. !$ esepio, .uesta atrice rappresenta un
.ua$rato latino(
1 2 3 4
2 1 4 3
i : t2 t1 t=
58
4 3 2 1
3 4 1 2
*crivere un algorito e00iciente che, $ata in input una atrice .ua$rata ;S1..n, 1..nT $i interi ar"itrari,
restituisca true se e solo se ; rappresenta un .ua$rato latino.
Soluzione. &er risolvere .uesto pro"lea puN essere utile iniziare a00rontan$o il sottopro"lea pi- seplice
che consiste nel capire se un array AS1..nT $i n interi contiene una e una sola volta tutti i valori in [1, W n\.
%n $ettaglio, $e0iniao una 0unzione ;=&;<A''AC( arra" A,1..n- .i int) #ool che restituisce true se e solo se
A contiene una e una sola volta tutti i valori nell'insiee [1, W n\. Bn o$o e00iciente per 0are ciN consiste
nell'usare una strategia ispirata a counting sort( $e0iniao un array $i "ooleani /S1..nT inizialente
inizializzato a false. &er ogni valore ! appartenente all'array A, controlliao innanzitutto se ! appartiene
all'insiee [1, W n\9 in caso a00erativo, controlliao /S!T( se vale false, signi0ica che a""iao incontrato
il valore ! per la pria volta e poniao /S!T a true. *e /S!T valeva giC true, signi0ica che il valore !
ripetuto. Bna volta terinata l'analisi $i tutti gli eleenti $i A senza aver ai trovato $uplicati, a""iao la
certezza che A conteneva tutti e soli i valori nell'insiee [1, W n\. 3tteniao .uin$i l'algorito seguente(
algoritmo ;=&;<A''AC( arra" A,1..n- .i int ) #ool
arra" F,1..n- .i #ool!
// Ini$iai$$a -
for i:$1 to n do
F,i- :$ @alAe!
endfor
// Cico di controo
for i:$1 to n do
int J :$ A,i-!
if ( J I 1 SS J 1 n ) then
return @alAe! // a&&ia#o tro%ato un %aore non %aido
else
if ( F,J- $$ trBe ) then
return @alAe! // a&&ia#o tro%ato un dupicato
else
F,J- :$ trBe!
endif
endif
endfor
return trBe!
,'algorito ;&;<A''AC cosa coe $escritto ha costo /n4, a causa $ella 0ase $i inizializzazione $ell'array tmp.
*i noti che, nel caso in cui 0osse possi"ile evitare l'inizializzazione, il costo sare""e 3/ n4 in .uanto
l'algorito potre""e terinare in tepo 3/14 nel caso ottio che si veri0ica .uan$o il prio eleento $i A
ha un valore che non appartiene all'insiee [1, 2, W n\.
! .uesto punto, la soluzione al nostro pro"lea $i partenza consiste nell'applicare la 0unzione 8he84TarraH
a$ ogni riga e ogni colonna $ella atrice ;, per controllare che restituisca sepre true.
algoritmo ;*N+'*22A9UAD'A+*2A+:N*( arra" M,1..n/ 1..n- .i int ) #ool
arra" tmp,1..n- .i int!
for i:$1 to n do
// copia a ri)a i-esi#a di ; ne!arra" t#p
for 0:$1 to n do
tmp,0- :$ M,i/ 0-!
endfor
// controa t#p
if ( ;=&;<A''AC(tmp) $$ @alAe )
return @alAe!
endif
// copia a coonna i-esi#a di ; ne!arra" t#p
5A Capitolo 3( 3r$inaento e <icerca 63MM!
for 0:$1 to n do
tmp,0- :$ M,0/ i-!
endfor
// controa t#p
if ( ;=&;<ZA''AC(tmp) $$ @alAe )
return @alAe!
endif
endfor
// se i controi sono stati superati' restituisce true
return trBe!
%l costo $ell'algorito 3/n
2
4. 9el caso pessio il costo /n
2
4 e si veri0ica .uan$o ; un .ua$rato latinoD
nel caso ottio il costo /n4 e si veri0ica .uan$o giC la pria riga 0allisce il controllo. !ttenzione che nel
caso ottio occorre coun.ue copiare aleno la pria riga nell'array tmp pria $i e00ettuare il controllo, e
tali operazioni richie$ono entra"e tepo /n4.
Z anche possi"ile $are una rappresentazione pi- copatta $ell'algorito, senza usare esplicitaente la
0unzione esterna ;=&;<A''AC( Bsiao $ue vettori "ooleani riga e 8ol che ci perettono $i controllare una riga
e una colonna conteporaneaente(
algoritmo ;*N+'*22A9UAD'A+*2A+:N*( arra" M,1..n/ 1..n- .i int ) #ool
arra" riga,1..n- .i #ool!
arra" 8ol,1..n- .i #ool!
int J!
for i:$1 to n do
// Ini$iai$$a )i arra" pri#a di o)ni itera$ione
for 0:$1 to n do
riga,0- :$ @alAe!
8ol,0- :$ @alAe!
endfor
for 0:$1 to n do
// Controa a ri)a i-esi#a
J :$ M,i/ 0-!
if ( JI1 SS J1n ) then
return @alAe!
else if ( riga,J- $$ trBe ) then
return @alAe!
else
riga,J- :$ trBe!
endif
// Controa a coonna i-esi#a
J :$ M,0/ i-!
if ( JI1 SS J1n ) then
return @alAe!
else if ( 8ol,J- $$ trBe ) then
return @alAe!
else
8ol,J- :$ trBe!
endif
endfor
endfor
// se i controi sono stati superati' restituisce true
return trBe!
*i noti che all'interno $ei $ue cicli 0or anni$ati usiao alternativaente i e j coe in$ici $i riga e $i colonna
alternativaente. %l costo $ell'algorito 3/n
2
4 coe nel caso prece$ente.
Esercizio 3.1!
*iete stati assunti coe consulenti $ella ?eleco per risolvere il seguente pro"lea. ;' $ato un array TS1..nT
5:
non or$inato $i nueri interi, ciascuno $ei .uali rappresenta un nuero $i tele0ono $i un a""onato $i
6ologna. ,a ?eleco vi in0ora che l'array T contiene poco eno $i 100000 nueri $i tele0ono, tutti
copresi nell'intervallo S200001, 300000T /estrei inclusi4 e nell'array non sono presenti $uplicati. *crivete
un algorito e00iciente per or$inare l'array T.
Soluzione. &ossiao osservare che l'array T coposto $a nueri $i > ci0re $eciali, che puN .uin$i essere
or$inato in tepo proporzionale alla sua $iensione usan$o 6uc7et *ort. %n realtC esiste anche un'altra
soluzione pi- seplice, "asata su una versione specializzata $i Counting *ort. Btilizziao un array $i
"ooleani $S1..100000T, inizializzato a 0alse, in cui risulterC $SiT I true se e solo se il valore 200000 E i esiste
in T. 1ato che per ipotesi l'array T non contiene $uplicati, non necessario usare un array $i contatori /coe
si usa nel Counting *ort convenzionale4 per tenere traccia $el nuero $i occorrenze $i ciascun valore.
algoritmo *'D:NA+&2( arra" +,1..n- .i int ) arra",1..n- .i int
arra" 6,1..100000- .i #ool!
for i :$ 1 to 100000 do
6,i- :$ @alAe!
endfor
for i :$ 1 to n do
6, +,i- " 200000 - :$ trBe!
endfor
int 0 :$ 1!
for i :$ 1 to 100000 do
if ( 6,i- $$ trBe ) then
+,0- :$ 200000%i!
0 :$ 0 % 1!
endif
endfor
return +!
*i presti particolare attenzione a coe l'array $ $e""a essere in$icizzatoD scrivere sepliceente $S TSiT T (I true
non sare""e stato corretto, in .uanto TSiT assue valori 0uori $all'intervallo vali$o $egli in$ici $i $.
Capitolo : /ashing
Esercizio .1
<icor$iao che una 0unzione hash )K L M [0, 1, W, m#1\ $etta (erfetta se per ogni coppia $i chiavi
$istinte ? e #, si ha )/?4 d )/#4.
1. *crivere un algorito per il calcolo $i una 0unzione hash per0etta in cui l'insiee universo sia
costituito $a se.uenze $i cin.ue caratteri scelti tra i seguenti( '!', 'C', '?', '@' e il valore $i m sia
inio possi"ile.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto prece$ente.
Soluzione. %nnanzitutto osserviao che ci sono 4
5
possi"ili chiavi, .uin$i mI4
5
I1024. Quin$i $o""iao
appare una chiave in un nuero copreso tra 0 e 4
5
#1 I 1023. ,'i$ea .uella $i consi$erare ciascuna
chiave coe un nuero in "ase 4, $ove le Gci0reH $el nostro sistea $i nuerazione sono !I0, CI1, ?I2 e
@I3. *ia IS1..5T l'array $i 5 caratteri che contiene la chiave. ,a 0unzione hash per0etta calcola il valore
$ell'espressione seguente(
)/I4 I 4
4
IS1T E 4
3
IS2T E 4
2
IS3T E 4
1
IS4T E 4
0
IS5T
$ove supponiao che le operazioni aritetiche vengano svolte sostituien$o ai caratteri i nueri $a 0 a 3,
coe riportato sopra. )/I4 rappresenta il valore $eciale che corrispon$e alla stringa I, interpretata coe se
0osse un nuero in "ase 4. ,'algorito per valutare l'espressione )/I4 puN essere scritto in .uesto o$o(
algoritmo =A)=DNA( arra" <,1..G- .i 8aratteri ) int
int riABltato :$ 0!
int 8! // ci*ra corrente
for i:$1 to G do
if (<,i- $$ UAU) then
8 :$ 0!
elseif (<,i- $$ U;U ) then
8 :$ 1!
elseif (<,i- $$ U+U) then
8 :$ 2!
else
8 :$ 3U
endif
riABltato :$ riABltato #4 % 8!
endfor
return riABltato!
%l costo coputazionale $ell'algorito 3/14. %n0atti l'algorito consiste in un ciclo il cui corpo viene
eseguito sepre e solo 5 volte, e il costo $i ciascuna iterazione 3/14. *i noti che la $iensione $ell'input
0issa e pari a 5.
>2 Capitolo 4( =ashing 63MM!
Esercizio .2
*ia $ato l'insiee $i chiavi I I [25, A3, 58, 2>, 13, >0, :3, 4\, e sia mI10. *i consi$eri una ta"ella hash
/inizialente vuota4 $i $iensione m. Mostrare coe ca"ia la struttura $ella ta"ella ogni volta che si
inserisce una $elle chiavi $i I, nell'or$ine in$icato. ,a 0unzione hash utilizzata )/k4 I k o$ m. ,a ta"ella
usa liste $i collisione /assuere che gli eleenti vengano sepre inseriti in 0on$o alle liste4.
Soluzione. Mostriao solo la con0igurazione 0inale(
Esercizio .3
%l pro0essor 1al Caso ha inventato un nuovo tipo $i 0unzione hash )/?4 che reputa e00icientissia. 2issata una
costante mJ1, la 0unzione ) appa una chiave ? in un intero scelto casualente nell'insiee [1, 2, ... , m\D il
valore casuale non $ipen$e in alcun o$o $al valore $i ?. *econ$o voi possi"ile realizzare una ta"ella hash
usan$o la 0unzione )/?4 $el pro0essor 1al CasoU @iusti0icare la risposta.
Soluzione. ,a 0unzione )/?4 $e0inita coe sopra non puN essere utilizzata per ipleentare una ta"ella hash.
%n0atti, per veri0icare se un oggetto ? presente nella ta"ella oppure no, sare""e sepre necessario esainare
l'intera ta"ella in .uanto la posizione iniziale )/?4 non 0ornisce alcuna in0orazione utile sulla presenza o
eno $i ?.
Esercizio .
*i consi$eri una ta"ella hash eorizzata in un vettore AS0..m # 1T con m I 10 slot in cui le collisioni sono
gestite e$iante in$irizzaento aperto. ,'insiee $elle chiavi costituito $a interi non negativi. ,a 0unzione
hash a$ottata )/k, i4 I //k o$ m4 E i4 o$ m, essen$o k il valore $ella chiave e i il contatore $el Gtentativo
$i inserientoH. Mostrare il contenuto $el vettore A $opo ciascuna $elle operazioni seguenti( /la soluzione
ostrata $opo ogni operazione4
%nseriento chiave 8
8
%nseriento chiave 1:
8 1:
%nseriento chiave 38
8 38 1:
Cancellazione chiave 8
1;, 38 1:
2G R3 GE 25
13
50
F3
4
0 1 2 3 4 G 5 E R F
>3
%nseriento chiave 21
21 1;, 38 1:
Cancellazione chiave 38
21 1;, 1;, 1:
%nseriento chiave 18
21 18 1;, 1:
%nseriento chiave 11
21 11 18 1;, 1:
Cancellazione chiave 21
1;, 11 18 1;, 1:
Esercizio .!
*i consi$eri una ta"ella hash con mI10 slot, gestita e$iante in$irizzaento aperto. ,e chiavi sono nueri
interi non negativi. %l pro0essor C. ?rullo propone $i generare la lista $i ispezioni $i una chiave k usan$o la
0unzione hash seguente(
)(k % i )=(k +2i )o$ m
<itenete che sia una "uona i$eaU @iusti0icare la risposta.
Soluzione. Bna se.uenza $i ispezione $eve pro$urre una perutazione $ei valori [0, 1, W, m#1\ in o$o $a
consentire l'esplorazione $i tutti gli slot $ella ta"ella. ,a 0unzione )/k, i4 esplora inizialente lo slot in
posizione k o$ m, .uin$i prosegue con /kE24 o$ m, /kE44 o$ m e cosa via. &urtroppo, poichO mI10, le
se.uenze $i ispezione cosa generate non visitano tutti gli slot, a solo .uelli in posizione pari o $ispari /in
"ase al valore iniziale $i k4. !$ esepio, se kI12, la se.uenza $i ispezione
2, 4, >, A, 0, 2, 4, >, A, 0
che coe si ve$e non consi$era ai gli slot in posizione $ispari. &ossiao .uin$i conclu$ere che la 0unzione
proposta non una 0unzione hash appropriata.
;' interessante osservare che il pro"lea si veri0ica solo .uan$o m /nuero $i slot nella ta"ella4 un nuero
pari. *e m 0osse $ispari, la 0unzione )/k, i4 pro$urre""e se.uenze $i ispezione che visitano tutti gli eleenti
$ella ta"ella, e .uin$i operere""e nel o$o corretto.
Capitolo !: Di0ide et Impera
Esercizio !.1
*i consi$eri il seguente pro"lea( $ato un array AS1..nT $i n 1 valori reali non or$inati, restituire il valore
inio in A.
1. *crivere un algorito ricorsi!o $i tipo di!ide et im(era per risolvere il pro"lea $i cui sopraD non
consentito usare varia"ili glo"ali.
2. Calcolare la coplessitC asintotica $ell'algorito proposto, otivan$o la rispostaD
3. 1are un liite in0eriore alla coplessitC $el pro"lea, nell'ipotesi in cui l'algorito risolutivo si "asi
solo su con0ronti. @iusti0icare la risposta.
Soluzione. ,'algorito puN essere $escritto coe segue(
algoritmo M:ND:W:D&&+:M>&'A( arra" A,1..n- .i dou#le/ int i/ int 0 ) dou#le
if ( i 1 0 ) then
errore2 %ettore %uoto
if ( i $$ 0 ) then
return A,i-!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
dou#le J1 :$ M:ND:W:D&&+:M>&'A(A/ i/ m)!
dou#le J2 :$ M:ND:W:D&&+:M>&'A(A/ m%1/ 0)!
if (J1 I J2) then
return J1!
else
return J2!
endif
endif
% paraetri i e j in$icano rispettivaente l'in$ice $el prio e $ell'ultio eleento /estrei inclusi4 in cui
e00ettuare la ricerca. ,a pria invocazione $ell'algorito .uin$i sarC M:ND:W:D&&+:M>&'A(A/1/n). ;' iportante
osservare che l'algorito richie$e tassativaente che il vettore sia non vuoto, cio n K 1, e restituisce un
errore nel caso venga invocato con i J j. *e n K 1 tale con$izione non si veri0icherC ai, cio la ricorsione
terina sepre con un vettore coposto $a un singolo eleento.
,a coplessitC asintotica si ricava risolven$o la seguente e.uazione $i ricorrenza(
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
!pplican$o il Master ?heore /caso 14, la soluzione T/n4 I R/n4.
&er ricavare un liite in0eriore, su00iciente consi$erare che un .ualsiasi algorito "asato su con0ronti $eve
necessariaente consi$erare ogni eleento $ell'array A aleno una volta /altrienti se viene saltato un
eleento, .uesto potre""e essere il inio e l'algorito non sare""e corretto4. Quin$i il liite in0eriore alla
coplessitC $el pro"lea Y/n4.
>> Capitolo 5( 1ivi$e et %pera 63MM!
Esercizio !.2
*i consi$eri un array AS1..nT coposto $a n 1 nueri reali, non necessariaente or$inato.
1. *crivere un algorito ricorsivo, $i tipo $ivi$e#et#ipera, per $eterinare il nuero $i eleenti in A
il cui valore sia aggiore o uguale a zeroD
2. !nalizzare il costo coputazionale $ell'algorito proposto.
Soluzione. Bna possi"ile soluzione la seguente(
algoritmo ;*N+AN*NN&(A+:W:( arra" A,1..n- .i dou#le/ int i/ int 0 ) int
if ( i 1 0 ) then
return 0! // arra" %uoto
elseif ( i $$ 0 ) then
if ( A,i- X 0 ) then return 1 else return 0 endif!
else
int m :$ F2**'( ( i % 0 )/2 )!
return ;*N+AN*NN&(A+:W:(A/ i/ m) % ;*N+AN*NN&(A+:W:(A/ m%1/ 0)!
endif
,'algorito viene invocato con ;*N+AN*NN&(A+:W:(A/ 1/ n). *ono presenti $ue casi "ase( /i4 il caso in cui il
sottovettore ASi..jT sia vuoto /i J j4, e /ii4 il caso in cui il sottovettore sia coposto $a un singolo eleento.
9el caso /i4 l'algorito restituisce 0, in .uanto in un vettore vuoto non sono presenti valori positivi. 9el caso
/ii4 l'algorito ritorna 1 oppure 0, a secon$a che l'unico valore presente sia non negativo o no. 9el caso in
cui ASi."jT contenga pi- $i un eleento, il sottovettore viene su$$iviso in $ue parti approssiativaente
uguali, e si restituisce la soa $ei valori nonnegativi presenti nelle $ue etC
%l costo coputazionale T/n4 $ell'algorito invocato su un vettore $i n eleenti so$$is0a l'e.uazione $i
ricorrenza(
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
che in "ase al Master ?heore ha soluzione T/n4 I R/n4.
Esercizio !.3
*crivere un algorito ricorsivo, $i tipo $ivi$e#et#ipera, per calcolare la soa $ei valori contenuti in un
array AS1..nT $i valori reali. *i richie$e che l'algorito $ivi$a ricorsivaente l'array in tre sottovettori $i
uguale lunghezza. Calcolare il costo coputazionale $ell'algorito utilizzan$o il Master ?heore.
Soluzione.
algoritmo )*MMA3( arra" A,1..n- .i dou#le/ int i/ int 0 ) dou#le
if ( i 1 0 ) then
return 0!
elseif ( i $$ 0 ) then
return A,i-!
else
int .1 :$ F2**'( i % (0 7 i % 1)/3 )!
int .2 :$ F2**'( i % (0 7 i % 1)#2/3 )!
return )*MMA3( A/ i/ .1 " 1 ) %
)*MMA3( A/ .1/ .2 7 1 ) %
)*MMA3( A/ .2/ 0 )!
endif
,'algorito viene invocato con )*MMA3(A/ 1/ n4. 3sserviao che la ricorsione presenta $ue casi G"aseH( il
caso $i sottovettore vuoto /i J j4, e il caso $i sottovettore con un singolo eleento ASiT. !$ ogni chiaata
ricorsiva, si calcolano le posizioni iniziali d0 e d2 $el secon$o e terzo sottovettore, rispettivaente. 2atto
>8
.uesto, il sottovettore viene iplicitaente scoposto in ASi..d0:0T, ASd0..d2#1T e ASd2..jT, e l'algorito
invocato ricorsivaente su ogni parte. %l calcolo $i d0 e d2 0atto in o$o tale $a garantisce il
coportaento corretto $ell'algorito anche .uan$o ASi..jT coposto $a 3 oppure 2 eleenti.
%l costo coputazionale so$$is0a la seguente e.uazione $i ricorrenza(
T (n)=
{
c
1
se n1
3T (n/3)+c
2
altrienti
che in "ase al Master ?heore ha soluzione T/n4 I /n4
Esercizio !.
*i consi$eri un array AS1..nT coposto $a n nueri interiD l'array A or$inato in senso non $ecrescente.
*crivere un algorito di!ide et im(era per $eci$ere se l'array contiene oppure no eleenti $uplicati.
!nalizzare il costo coputazionale $ell'algorito proposto. *econ$o voi l'algorito potre""e essere reso
asintoticaente pi- e00icienteU
Soluzione. ,'algorito &):)+*N*DU>2:;A+:( A/ i/ 0 ) restituisce true se e solo se esistono valori $uplicati nel
sottovettore ASi..jT
algoritmo &):)+*N*DU>2:;A+:( arra" A,1..n- .i int/ int i/ int 0 ) #ool
if ( i X 0 ) then
return @alAe!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
return ( A,m- $$ A,m%1- SS &):)+*N*DU>2:;A+:(A/i/m) SS &):)+*N*DU>2:;A+:(A/m%1/0) )!
endif
9el caso in cui il sottovettore ASi..jT sia vuoto o contenga un singolo eleento /cio .uan$o i K j4, l'algorito
restituisce false, in .uanto non possono esistere $uplicati. *e il sottovettore contiene pi- $i un eleento,
l'algorito restituisce true se e solo se una $elle tre seguenti alternative vera(
1. % $ue eleenti ASmT e ASmE1T Ga cavalloH $elle $ue etC $i ASi..jT sono ugualiD oppure
2. ;sistono $uplicati nel sottovettore ASi..mTD oppure
3. ;sistono $uplicati nel sottovettore ASmE1..jT
%n "ase al Master ?heore, l'algorito ha costo T/n4 I /n4. Qualsiasi algorito $eve necessariaente
esainare tutti gli eleenti aleno una volta nel caso peggioreD .uin$i ogni algorito risolutivo per .uesto
pro"lea richie$erC /n4 nel caso peggiore.
Esercizio !.!
Bna inversione in un array .S1..nT $i n nueri reali una coppia $i in$ici i, j tali che i Q j e .SiT J .SjT.
1. *crivere un algorito iterativo che $ato un array . calcola il nuero $i inversioni presenti in . in
tepo 3/n
2
4.
2. *crivere un algorito $ivi$e#et#ipera che $ato un array . calcola il nuero $i inversioni in tepo
3/n log n4. -uggerimentoK considerare un algoritmo simile a ;C4GCSO4T9 in (articolare% la fase in
cui si combinano i risultati (ar@iali (uN essere im(lementata in modo simile alla o(era@ione merge
di ;C4GCSO4T.
Soluzione. %niziao proponen$o la soluzione eno e00iciente, richiesta al punto 1. ,'i$ea .uella $i
con0rontare tra $i loro tutti gli eleenti .SiT, .SjT con iQj, e contare .uanti $i loro sono nell'or$ine GerratoH.
algoritmo ;*N+A:NW&'):*N:N*N&FF( arra" A,1..n- .i dou#le ) int
int inJ :$ 0! // nu#ero di in%ersioni
for i :$ 1 to n"1 do
for 0 :$ i%1 to n do
>A Capitolo 5( 1ivi$e et %pera 63MM!
if ( W,i- 1 W,0- ) then
inJ :$ inJ % 1!
endif
endfor
endfor
return inJ!
%l costo $i .uesta soluzione, coe richiesto 3/n
2
4 /per la precisione, il costo /n
2
4 in .uanto il costo nel
caso ottio coinci$e con .uello nel caso pessio4.
Bna soluzione pi- e00iciente consiste nell'utilizzare una variante $i Merge*ort, coe segue(
algoritmo ;*N+A:NW&'):*N:( arra" A,1..n- .i dou#le/ int i/ int 0 ) int
if ( i X 0 ) then
return 0!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
int 81 :$ ;*N+A:NW&'):*N:(A/ i/ m)!
int 82 :$ ;*N+A:NW&'):*N:(A/ m%1/ 0)!
int 83 :$ ;*N+A:NW&'):*N:M&'(&(A/ i/ m/ 0)!
return 81 % 82 % 83!
endif
algoritmo ;*N+A:NW&'):*N:M&'(&(arra" A,1..n- .i dou#le/ int i/ int m/ int 0) int
arra" tmp :$ arra" ,1..(0 7 i % 1)- .i dou#le!
int 8 :$ 0!
int 4 :$ 1!
int i1 :$ i!
int i2 :$ m % 1!
)hile (i1 3 m ?? i2 3 0) do
if (A,i1- 3 A,i2-) then
tmp,4- :$ A,i1-!
i1 :$ i1 % 1!
else
8 :$ 8 % (m % 1 " i1)!
tmp,4- :$ A,i2-!
i2 :$ i2 % 1!
endif
4 :$ 4%1!
end)hile
)hile (i1 3 m) do
tmp,4- :$ A,i1-!
i1 :$ i1 % 1!
4 :$ 4 % 1!
end)hile
)hile (i2 3 0) do
tmp,4- :$ A,i1-!
i1 :$ i1 % 1!
4 :$ 4 % 1!
end)hile
for 4$1 to (0 7 i % 1) do
A,i%4"1- :$ tmp,4-!
endfor
return 8!
Esercizio !.$
,'!genzia 9azionale per la ]alutazione $el sistea Bniversitario $ella <uritania /!9]B<4 ha $eciso $i
valutare i $ocenti e ricercatori universitari in vista $i una proozione, utilizzan$o l'ine$ito eccaniso
>:
seguente. ! ciascuno $egli n ricercatori associato un Gin$ice $i "ravuraH reale non negativo( pi- alto, pi-
il ricercatore consi$erato G"ravoH. % ricercatori sono stati or$inati in o$o che i loro in$ici $i "ravura GS1T,
GS2T, ..., GSnT risultino in or$ine non $ecrescente /GSiT l'in$ice $i "ravura $el ricercatore i#esio4. ! .uesto
punto, l'!9]B< ha $e0inito, usan$o non eglio precisate GapprossiazioniH, un nuero reale non negativo
7. ]erranno proossi solo i ricercatori il cui in$ice $i "ravura sia strettaente aggiore $i k.
1. *crivere un algorito e00iciente che, $ato il vettore or$inato GS1..nT e la soglia k, calcola il nuero
totale $i ricercatori proossi.
2. 1eterinare il costo coputazionale asintotico $ell'algorito proposto al punto 1.
Soluzione. %niziao con la soluzione pi- seplice( e00ettuiao una scansione $i tutto l'array, contan$o
.uanti sono gli eleenti aggiori $i k(
algoritmo ;*N+A>'*M*)):1( arra" =,1..n- .i dou#le/ dou#le 4 ) int
int 8 :$ 0! // contatore
for i:$1 to n do
if ( =,i- 1 4 ) then 8 :$ 8%1! endif!
endfor
return 8!
%l costo $ell'algorito /n4.
]e$iao ora una soluzione arginalente pi- e00iciente. *0ruttan$o il 0atto che l'array G or$inato,
possiao evitare la scansione copleta e 0erarci al prio eleento il cui valore J kD i0atti, sappiao
che tutti gli eleenti successivi saranno anch'essi aggiori $i k.
algoritmo ;*N+A>'*M*)):2( arra" =,1..n- .i dou#le/ dou#le 4 ) int
int i :$ 1!
)hile ( i 3 n ?? =,i- 3 4 ) do
i :$ i % 1!
end)hile
return (n"i%1)!
%l costo in .uesto caso 3/n4, in .uanto non necessariaente si scorre l'intero array. *e tutti i ricercatori
hanno in$ice $i "ravura sotto la soglia k, l'algorito terina in /n4 passi /caso pessio4. *e tutti i
ricercatori hanno in$ice $i "ravura sopra la soglia k /caso ottio4, l'algorito richie$e 3/14 iterazioni in
.uanto risulterC GS1T J k, e il ciclo 'hile terina ie$iataente.
]e$iao in0ine la soluzione e00iciente, che si "asa sulla ricerca "inaria per contare .uanti valori $i G
risultano strettaente aggiore $i k. ,a 0unzione ;*N+A>'*M*)):3(=/ 4/ i/ 0) restituisce il nuero $egli
eleenti $el sottovettore GSi..jT che risultano aggiori $i k /tenen$o presente che G or$inato in senso
crescente4(
algoritmo ;*N+A>'*M*)):3( arra" =,1..n- .i dou#le/ dou#le 4/ int i/ int 0 ) int
if ( i 1 0 ) then
return 0! // (1)
else
int m :$ F2**'( ( i % 0 ) / 2 )!
if ( =,m- 3 4 ) then
return ;*N+A>'*M*)):3( =/ 4/ m%1/ 0 )! // (2)
else
return (0"m%1) % ;*N+A>'*M*)):3( =/ 4/ i/ m"1 )! // (=)
endif
endif
,'algorito viene inizialente invocato con ;*N+A>'*M*)):3(=/ 4/ 1/ n), essen$o n il nuero $i eleenti $i
G. !$ ogni passo(
se i J j, allora stiao e00ettuan$o il conteggio sul sottovettore vuoto, in cui il risultato $ell'algorito
zero /linea /14 4D
se i j coe pria cosa $eteriniao la posizione m $ell'eleento centrale, esattaente coe si 0a
80 Capitolo 5( 1ivi$e et %pera 63MM!
con la ricerca "inaria. 1istinguiao $ue sottocasi(
se GSmT L k, l'eleento centrale sotto la soglia. Quin$i il conteggio prosegue consi$eran$o
esclusivaente gli eleenti che stanno a $estra $i GSmT, ossia .uelli nel sottovettore GSmE1...cT
/linea /24 4D
se GSmT J k, l'eleento centrale sopra la soglia. Quin$i, essen$o l'array or$inato, tutti gli /j#
mE14 eleenti in GSm..jT risultano sopra la soglia. %l nuero $i tali eleenti, soato al
conteggio $i .uelli sopra soglia in GSi..m#1T /che viene calcolato $alla chiaata ricorsiva4
pro$uce il risultato /linea /34 4.
! titolo $i esepio, si consi$eri il vettore seguente con soglia kI5 /il nuero in$icato sopra agli eleenti $el
vettore rappresenta l'in$ice $ella cella4.
0 2 1 2 3 4 5
2 3 5 > > 8 A
,'in$ice m $ella posizione centrale $el vettore mI4, che contiene il valore >. Quin$i supponen$o $i avere
invocato la 0unzione coe calcolo $i ;*N+A>'*M*)):3(=/ G/ 1/ E), verrC eseguita la linea etichettata con /34,
che calcola il risultato ricorsivaente coe (E"4%1) % ;*N+A>'*M*)):3(=/ G/ 1/ 3).
%l costo coputazionale T/n4 $i .uesto algorito so$$is0a l'e.uazione $i ricorrenza T/n4 I T/n)24 E 3/14, che
in "ase al Master ?heore ha soluzione T/n4 I 3/log n4
Esercizio !.%
*i consi$eri un array AS1..nT contenente n valori reali $istinti or$inati in senso crescente. *crivere un
algorito e00iciente che, $ato l'array A e un nuero reale ar"itrario ?, restituisce l'in$ice $el pi- piccolo
eleento in A che risulti strettaente aggiore $i ?. *e non esiste alcun valore $i A che so$$is0a tale
vincolo, l'algorito $eve restituire nE1 /ossia l'in$ice $el prio eleento $opo l'ultio presente in A4. !$
esepio, se A I S1, 1.A, 2, 2.3, 3.4T e ? I 2.5, l'algorito $eve restituire 4, in .uanto AS4T I 2.3 risulta essere
il inio valore presente in ! strettaente aggiore $i ?. *e A I S1, 2.5, 2.>, 3, 3.4, 5.2, 8T e ? I 3.4,
l'algorito restituisce >, in .uanto AS>T I 5.2 il inio valore presente in A che risulti strettaente
aggiore $i ?. %n0ine, se A I S1, 2, 3T e ? I 3.5, l'algorito restituisce 4.
Soluzione. &er risolvere .uesto pro"lea possiao utilizzare una versione a$eguataente o$i0icata
$ell'algorito $i ricerca "inaria. Chiaao l'algorito U>>&'6*UND, noe usato $alla li"reria *?, $el
linguaggio CEE per in$icare la 0unzione che risolve .uesto pro"lea. Mentre le ipleentazioni *?, usano
prevalenteente una soluzione iterativa, ostriao .ui una ipleentazione ricorsiva.
algoritmo U>>&'6*UND( arra" A,1..n- .i dou#le/ dou#le L/ int i/ int 0) int
if ( i 1 0 ) then
return i!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
if ( A,m- L L ) then
return U>>&'6*UND( A/ L/ m%1/ 0 )!
else
return U>>&'6*UND( A/ L/ i/ m"1 )!
endif
endif
=,m"1- =,m%1- =,i- =,0-
:"#>1 elementi
=,m-
81
,a precon$izione $i .uesto algorito /cio la proprietC che i paraetri $i input $evono so$$is0are4 la
seguente
k=1,... i 1( A[ k ]?
k=j +1,... n( A[ k ]>?
ossia tutti gli eleenti Ga sinistraH $i ASiT son inori o uguali a ?, entre tutti .uelli Ga $estraH $i ASjT
risultano strettaente aggiori $i ?. *i noti che inizialente iI1 e jIn, per cui entra"e le proprietC valgono
"analente in .uanto a sinistra $i ASiT e a $estra $i ASjT non ci sono eleenti. *i puN poi veri0icare che la
precon$izione continua a essere so$$is0atta per tutte le chiaate ricorsive.
,a precon$izione $i cui sopra utile per $e0inire correttaente cosa restituire .uan$o si veri0ica il caso "ase
$ella ricorsione /ossia .uan$o i J j4. Quan$o i I jE1, in0atti, la precon$izione si puN riscrivere coe(
k=1,... i 1( A[ k ]?
k=i %... n( A[ k ]>?
per cui la posizione $el inio eleento $i A strettaente aggiore $i ? la posizione i#esia.
&er risolvere il pro"lea GsietricoH $i in$ivi$uare la posizione $el pi- gran$e valore in A che risulti
strettaente inore $i ? possiao usare il seguente algorito 2*Y&'6*UND
algoritmo 2*Y&'6*UND( arra" A,1..n- .i dou#le/ dou#le L/ int i/ int 0 ) int
if ( i 1 0 ) then
return 0!
else
int m :$ F2**'( ( i % 0 ) / 2 )!
if ( A,m- K L ) then
return 2*Y&'6*UND( A/ L/ i/ m"1 )!
else
return 2*Y&'6*UND( A/ L/ m%1/ 0 )!
endif
endif
Esercizio !.&
*i consi$eri un array AS1..nT contenente valori interi or$inati in senso non $ecrescenteD possono essere
presenti valori $uplicati. *crivere un algorito ricorsivo $i tipo $ivi$e#et#ipera che, $ato in input A e un
intero ?, restituisce l'in$ice /la posizione4 $ella pria occorrenza $i ? in A, oppure restituisce nE1 se il valore
? non presente. !$ esepio, se AIS1, 3, 4, 4, 4, 5, >, >T e ?I4, l'algorito $eve restituire 3, in .uanto AS3T
la pria occorrenza $el valore 4. Mo$i0icare .uin$i l'algorito per restituire la posizione $ell'ultima
occorrenza $i ? in A, oppure 0 se ? non presente.
Soluzione. %l pro"lea si puN risolvere con una variante $ella ricerca "inaria. ,'algorito
;&';A>':MA*;;*''&NMA(A/ L/ i/ 0) restituisce l'in$ice $ella pria occorrenza $el valore ? all'interno $el
sottovettore or$inato ASi..jT. % paraetri $i input $ell'algorito $evono so$$is0are le seguenti precon$izioni
/oltre al 0atto che A $eve essere or$inato in senso non $ecrescente4(
k=1,... i 1( A[ k ]<?
k=j +1,... n( A[ k ]?
1ate le precon$izioni sopra e $etta m la posizione centrale $el sottovettore ASi..jT, m il risultato cercato se
ASmT II ?, e vale una $elle seguenti con$izioni(
1. siao all'inizio $el sottovettore /m II i4, oppure
2. l'eleento prece$ente ASm#1T ha valore $iverso $a ?.
*e nessuna $elle $ue con$izioni vale, la ricerca prosegue ricorsivaente su una $elle $ue etC $el
82 Capitolo 5( 1ivi$e et %pera 63MM!
sottovettore ASi..jT, in o$o tale $a antenere vali$a la precon$izione $i cui sopra.
algoritmo ;&';A>':MA*;;*''&NMA( arra" A,1..n- .i int/ int L/ int i/ int 0 ) int
if ( i 1 0 ) then
return n%1! // %aore 9 non tro%ato
else
int m :$ F2**'( (i % 0) / 2 )!
if ( A,m- $$ L ?? ( m $$ i SS A,m- K A,m"1- ) then
return m!
elseif ( A,m- X L ) then
return ;&';A>':MA*;;*''&NMA( A/ L/ i/ m"1 )!
else
return ;&';A>':MA*;;*''&NMA( A/ L/ m%1/ 0 )!
endif
endif
,'algorito GsietricoH ;&';AU2+:MA*;;*''&NMA(A/ L/ i/ 0) puN essere utilizzato per restituire la posizione
$ell'ultia occorrenza $el valore ? nel sottovettore or$inato ASi..jT, oppure 0 se ? non presente.
algoritmo ;&';AU2+:MA*;;*''&NMA( arra" A,1..n- .i int/ int L/ int i/ int 0 ) int
if ( i 1 0 ) then
return 0! // %aore 9 non tro%ato
else
int m :$ F2**'( (i % 0) / 2 )!
if ( A,m- $$ L ?? ( m $$ 0 SS A,m- K A,m%1- ) then
return m!
elseif ( A,m- 3 L ) then
return ;&';AU2+:MA*;;*''&NMA( A/ L/ m%1/ 0 )!
else
return ;&';AU2+:MA*;;*''&NMA( A/ L/ i/ m"1 )!
endif
endif
Esercizio !.'
*i consi$eri un array AS1..nT contenente valori reali or$inati in senso non $ecrescenteD l'array puN contenere
valori $uplicati. *crivere un algorito ricorsivo e00iciente $i tipo $ivi$e#et#ipera che, $ato l'array A e $ue
nueri reali .ualsiasi lo> Q u(, calcola .uanti valori $i A appartengono all'intervallo Slo>, u(T. 1eterinare
il costo coputazionale $ell'algorito proposto.
Soluzione. %niziao con la soluzione pi- seplice. ,'algorito seguente conta i valori appartenenti
all'intervallo Sl, uT che si trovano nel sottovettore ASi..jT. ,'algorito $ivi$e il sottovettore in $ue parti aventi
circa la stessa $iensione, e invoca se stesso ricorsivaente sulle $ue etC
algoritmo ;*N+A:N+&'WA22*( arra" A,1..n- .i dou#le/ dou#le low/ dou#le Bp/ int i/ int 0 )
int
if ( i 1 0 ) then
return 0!
elseif ( i $$ 0 ) then
if ( A,i- X low ?? A,i- 3 Bp ) then return 1! else return 0! endif1
else
int m :$ F2**'( ( i % 0 ) / 2 )!
return ;*N+A:N+&'WA22*(A/ low/ Bp/ i/ m)! % ;*N+A:N+&'WA22*(A/ low/ Bp/ m%1/ 0)!
endif
,'algorito viene invocato con ;*N+A:N+&'WA22*(A/ low/ Bp/ 1/ n). %l suo costo T/n4 so$$is0a la seguente
e.uazione $i ricorrenza(
83
T (n)=
{
c
1
se n1
2T (n/ 2)+c
2
altrienti
,'applicazione $el Master ?heore porta alla soluzione T/n4 I /n4. Questo vale sia nel caso ottio che nel
caso pessio.
Bna soluzione pi- coplessa a pi- e00iciente consiste nell'usare gli algoriti U>>&'6*UND e 2*Y&'6*UND
$escritti nell';sercizio 5.8. ,a 0unzione 2*Y&'6*UND restituisce l'in$ice $ell'eleento $i A il cui valore viene
Gie$iataente priaH $i lo>, entre la 0unzione U>>&'6*UND restituisce l'in$ice $ell'eleento $i A il cui
valore viene Gie$iataente $opoH $i u(.
algoritmo ;*N+A:N+&'WA22*( arra" A,1..n- .i dou#le/ dou#le low/ dou#le Bp ) int
int @irAt :$ 2*Y&'6*UND(A/ low/ 1/ n)!
int laAt :$ U>>&'6*UND(A/ Bp/ 1/ n)!
return laAt 7 @irAt 7 1!
%l costo $i .uesto algorito 3/log n4 nel caso peggiore.
Esercizio !.1(
*i consi$eri un array AS1..nT coposto $a n 1 valori interi tutti $istinti. *upponiao che l'array sia or$inato
in senso crescente /AS1T < AS2T < W < ASnT4.
1. *crivere un algorito e00iciente che, $ato in input l'array A, $eterina un in$ice i, se esiste, tale che
ASiT I i. 9el caso esistano pi- in$ici che so$$is0ano la relazione prece$ente, su00iciente restituirne
uno .ualsiasi.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Z possi"ile utilizzare il seguente algorito ricorsivo, olto siile a .uello $ella ricerca "inaria /i
e c rappresentano rispettivaente gli in$ici estrei $el sottovettore ASi..jT in cui e00ettuare la ricerca, all'inizio
la 0unzione va invocata con iI1, jIn4((
algoritmo ;&';A:( arra" A,1..n- .i int/ int i/ int 0 ) int
if (i 1 0) then
errore NNon eAiAte al8Bn i tale 8he A,i- $ iP
endif
int m :$ F2**'( (i % 0) / 2 )!
if ( A,m- $$ m ) then
return m!
elseif (A,m- 1 m ) then
return ;&';A:(A/i/m"1)!
else
return ;&';A:(A/m%1/0)!
endif
*i noti che i valori contenuti nel vettore potre""ero anche essere negativi, per cui si puN anche avere il caso
in cui ASmT Q m.
9otiao che se ASmT Q m, l'in$ice i tale per cui ASiTIi non potrC ai trovarsi nella pria eta' ASi..m#1T, in
.uanto per ipotesi /il vettore contiene tutti interi $istinti, e$ or$inato4 si avrC che ASkT Q k per ogni kIi, iE1,
W m#1. &er ren$ersi conto $i cio', consi$eriao ASm#1T. &oichO l'array or$inato e non esistono $uplicati, si
ha che ASm#1T Q ASmT. Ma poichO ASmT Q m, si ha( ASm#1T Q ASmT Q m, $a cui ASm#1T Q m#1. ,o stesso
ragionaento si puo' ripetere per m#2, m#3 eccetera. %l ragionaento sietrico si applica al caso ASmT J m.
,'algorito proposto una seplice variante $ell'algorito $i ricerca "inaria, e ha lo stesso costo
coputazionale 3/log n4.
Capitolo $: 2ecniche 3reed"
Esercizio $.1
1isponiao $i un tu"o etallico $i lunghezza =. 1a .uesto tu"o vogliao ottenere al pi- n segenti pi-
corti, aventi rispettivaente lunghezza -S1T, -S2T, W, -SnT. %l tu"o viene segato sepre a partire $a una $elle
estreitC, .uin$i ogni taglio ri$uce la sua lunghezza $ella isura asportata.
1. *crivere un algorito e00iciente per $eterinare il nuero assio $i segenti che possi"ile
ottenere. 2oralente, tra tutti i sottoinsiei $egli n segenti la cui lunghezza coplessiva sia
inore o uguale a =% vogliao $eterinarne uno con car$inalitC assiale.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Questo pro"lea si puN risolvere con un algorito gree$y. 3r$iniao le sezioni in senso non
decrescente rispetto alla lunghezza, in o$o che il segento 1 a""ia lunghezza inia e il segento n
lunghezza assia. &roce$iao .uin$i a segare pria il segento pi- corto, poi .uello successiva e cosa via
0inchO possi"ile /cio 0ino a .uan$o la lunghezza resi$ua ci consente $i ottenere aleno un'altro segento4.
,o pseu$oco$ice puN essere $escritto in .uesto o$o
algoritmo MAQNUM)&M:*N:( dou#le 2/ arra" ),1..n- .i dou#le ) int
*'D:NA;'&);&N+&())!
int i :$ 1!
)hile ( i 3 n ?? 2 X ),i- ) do
2 :$ 2 " ),i-! // di#inuisce a un)7e$$a residua
i :$ i % 1!
end)hile
return i " 1!
,'operazione $i or$inaento puN essere 0atta in tepo /n log n4 usan$o un algorito $i or$inaento
generico. %l successivo ciclo 'hile ha costo 3/n4 nel caso peggiore. %l costo coplessivo $ell'algorito
risulta .uin$i /n log n4.
*i noti che l'algorito $i cui sopra restituisce l'output corretto sia nel caso in cui gli n segenti a""iano
coplessivaente lunghezza inore o uguale a =, sia nel caso opposto in cui nessuno a""ia lunghezza
inore o uguale a = /in .uesto caso l'algorito restituisce zero4.
Esercizio $.2
*iete stati assunti alla Microso0t per lavorare alla prossia versione $i eor$, $enoinata eor$ 2030. %l
pro"lea che $ovete risolvere il seguente. Z $ata una se.uenza $i n parole, le cui lunghezze /espresse in
punti tipogra0ici, nueri interi4 sono eorizzate nel vettore >S1T, W, >SnT. Z necessario su$$ivi$ere le
parole in righe $i lunghezza assia pari a = punti tipogra0ici, in o$o che lo spazio non utilizzato in
ciascuna riga sia inio possi"ile" ?ra ogni coppia $i parole consecutive posizionate sulla stessa riga viene
inserito uno spazio che occupa - punti tipogra0iciD nessuno spazio viene inserito $opo l'ultia parola $i ogni
riga. ,a lunghezza $el testo su ogni riga .uin$i $ata $alla soa $elle lunghezze $elle parole e $egli spazi
$i separazione. = aggiore $ella lunghezza $i ogni singola parola /.uin$i in ogni riga puN sepre essere
inserita aleno una parola4. 9on possi"ile rior$inare le parole, che $evono coparire esattaente
8> Capitolo >( ?ecniche @ree$y 63MM!
nell'or$ine $ato.
1. *crivere un algorito e00iciente che, $ato in input il vettore >S1T, W, >SnT, e i valori - e =, stapi
una su$$ivisione $elle parole che iniizza lo spazio inutilizzato in ciascuna riga. !$ esepio,
supponen$o $i avere 15 parole, l'algorito potre""e stapare la stringa GS1 3TS4 ATS: 15TH per
in$icare che la pria riga contiene le parole $a 1 a 3 /incluse4, la secon$a le parole $a 4 a A, e la
terza le parole $a : a 15.
2. !nalizzare il costo coputazionale $ell'algorito proposto.
Soluzione. Z possi"ile risolvere il pro"lea con un seplice algorito gree$y( si inseriscono in ciascuna
riga le parole, nell'or$ine in$icato, 0inchO non si supera la lunghezza assia consentita. Btilizziao la
varia"ile Atart per in$icare l'in$ice $ella pria parola $ella riga correnteD ,res la lunghezza resi$ua /ancora
$a riepire4 $alla riga corrente.
algoritmo F*'MA++A>A'A('AF*( arra" w,1..n- .i int/ int )/ int 2 )
int Atart :$ 1!
int 2reA :$ 2 " w,1-!
for i :$ 2 to n do
if ( 2reA X ) % w,i-) then// a))iun)ia#o a paroa i-esi#a aa ri)a corrente
2reA :$ 2reA 7 ) " w,i-!
else // ini$ia#o una nuo%a ri)a
print N,N % Atart % N N % (i"1) % N-P!
Atart :$ i!
2reA :$ 2 " w,i-!
endif
endfor
print N,N % Atart % N N % n % N-P!
*i noti la stapa e00ettuata al terine $el ciclo G0orH, senza la .uale l'algorito non verre""ero stapate le
parole $ell'ultia riga. %l costo $ell'algorito /n4.
Esercizio $.3
*upponiao $i avere n K 1 oggetti, ciascuno etichettato con un nuero $a 1 a nD. l'oggetto i#esio ha peso
(SiT J 0. Questi oggetti vanno inseriti all'interno $i scatoloni i$entici, $isponi"ili in nuero illiitato,
ciascuno in gra$o $i contenere un nuero ar"itrario $i oggetti purchO il loro peso coplessivo sia inore o
uguale a <" *i puN assuere che tutti gli oggetti a""iano peso inore o uguale a <. % pesi sono valori reali
ar"itrari. ]ogliao $e0inire un algorito che $isponga gli oggetti negli scatoloni in o$o $a cercare $i
iniizzare il nuero $i scatoloni utilizzati. Questo genere $i pro"lea noto col noe $i bin (acking
(roblem e$ coputazionalente intratta"ile nel caso generaleD $i conseguenza, ci accontentiao $i un
algorito seplice che pro$uca una soluzione non necessariaente ottia.
1. *crivere un algorito "asato sul para$iga gree$y che, $ato il vettore $ei pesi (S1..nT e il valore <,
restituisce il nuero $i scatoloni che vengono utilizzati.
2. Calcolare il costo coputazionale $ell'algorito proposto.
Soluzione. Bn algorito gree$y olto seplice consiste nel consi$erare tutti gli oggetti, nell'or$ine in cui
sono $ati. &er ogni oggetto, si controlla se puN essere inserito nello scatolone corrente senza superare il liite
$i peso. *e ciN non possi"ile, si pren$e un nuovo scatolone e lo si inizia a riepire.
algoritmo );A+*2*N:( arra" p,1..n- .i dou#le/ dou#le ; ) int
int nA :$ 0! // nu#ero di scatooni utii$$ati
int i :$ 1!
)hile ( i 3 n ) do
nA :$ nA % 1! // ini$ia#o a rie#pire un nuo%o scatoone
dou#le ;reA :$ ;! // capacit3 residua deo scatoone corrente
)hile ( i 3 n ?? ;reA X p,i- ) do
;reA :$ ;reA 7 p,i-!
i :$ i % 1!
88
end)hile
end)hile
return nA!
,'algorito 0a uso $ella varia"ile intera nA, che antiene il nuero $i scatoloni utilizzati, e $ella varia"ile
reale ;reA che in$ica la capacitC resi$ua $ello scatolone corrente. *e la capacitC resi$ua ;reA supera il peso
(SiT $ell'oggetto i#esio, allora tale oggetto puN essere inserito nello scatoloneD si provve$e .uin$i a
$ecreentare ;reA $i (SiT e si passa all'oggetto successivo. Quan$o ;reA $iventa in0eriore a (SiT, allora
l'oggetto i non trova posto nello scatolone corrente, e si inizia a riepire il successivo.
%l costo coputazionale $ell'algorito proposto /n4.
Esercizio $.
1isponiao $i n K 1 li"ri $i varia $iensioneD il li"ro i#esio ha spessore ?SiT e altezza #SiTD le isure sono
nueri reali. ]ogliao $isporre i li"ri uno accanto all'altro, senza rior$inarli, su sca00ali $i lunghezza =.
Ciascuno sca00ale in gra$o $i ospitare un nuero .ualsiasi $i li"ri, purchO la soa $egli spessori risulti
inore o uguale a =D naturalente nessun li"ro ha spessore aggiore $i =. 3gni sca00ale $eve essere
riepito il pi- possi"ile. @li sca00ali vengono posizionati uno sotto l'altro in o$o $a non sprecare spazio in
verticale. ,'altezza $i ciascuno sca00ale pari all'altezza assia $ei li"ri che contiene. ,'altezza
coplessiva occupata $all'intera collezione $i li"ri $ata $alla soa $elle altezze $ei singoli sca00ali.
*crivere un algorito gree$y che, $ati in input i vettori ?S1..nT e #S1..nT, e il valore $i =, restituisce l'altezza
totale occupata $alla collezione $i li"ri. !nalizzare il costo asintotico $ell'algorito proposto.
Soluzione. ,'algorito s0rutta l'i$ea seguente( si consi$erano a turno tutti i li"ri, nell'or$ine in cui sono $ati.
*i posiziona ciascun li"ro sullo sca00ale corrente 0inchO possi"ileD conteporaneaente, si tiene traccia
$ell'altezza assia $ei li"ri $elo sca00ale. Quan$o si 0inito $i riepire uno sca00ale, si aggiorna l'altezza
coplessiva e si proce$e con lo riepiento $ello sca00ale successivo.
,'algorito puN essere $escritto nel o$o seguente(
algoritmo S;AFFA2:( arra" L,1..n- .i dou#le/ arra" H,1..n- .i dou#le/ dou#le 2 ) dou#le
dou#le h :$ 0! // ate$$a co#pessi%a di tutti )i sca**ai
int i :$ 1! // indice de i&ro c7e consideria#o/
)hile ( i 3 n ) do
dou#le 2reA :$ 2! // ar)7e$$a residua sca**ae corrente
dou#le hmaL :$ 0! // ate$$a sca**ae corrente
)hile ( i 3 n ?? 2reA X L,i- ) do
2reA :$ 2reA 7 L,i-! // posi$iono i i&ro i-esi#o suo sca**ae
if ( H,i- 1 hmaL ) then
hmaL :$ H,i-!
endif
i :$ i % 1!
end)hile
h :$ h % hmaL! // a))iorna te$$a sca**ae corrente
end)hile
return h!
%l costo $ell'algorito /n4.
Esercizio $.!
Bn coesso viaggiatore utilizza il treno per i suoi spostaenti. =a piani0icato n K 1 visite ai suoi clienti $a
e00ettuare in n giorni $iversi gS1T, W gSnT $ell'anno in corso. ,'array gS1..nT contiene valori interi
appartenenti all'insiee [0, W 3>4\ /$ove 0 in$ica il prio gennaio, 3>4 in$ica il 31 $ice"re4D l'array non
contiene valori $uplicati e$ or$inato in senso crescente. %l coesso viaggiatore puo' $eci$ere $i utilizzare
"iglietti singoli, $el costo $i - euro, che valgono per un solo giorno, oppure $i ac.uistare un a""onaento
$ella $urata $i 30 giorni /incluso il giorno $i eissione4 $el costo $i A euroD si puN assuere che A Q 30-.
8A Capitolo >( ?ecniche @ree$y 63MM!
%n generale potrC risultare econoicaente conveniente ac.uistare un i^ $i "iglietti e a""onaenti in
o$o $a poter e00ettuare tutti i viaggi iniizzan$o il costo.
*crivere un algorito gree$y che $ato l'array gS1..nT e i costi - e A $el "iglietto singolo e $ell'a""onaento,
$eterina la co"inazione ottia $i "iglietti e a""onaenti che consentono $i e00ettuare tutti i viaggi al
costo inio possi"ile.
Soluzione.
W:A((:( arra" g,1..n- .i int/ real )/ real A )
int i :$ 1 !
)hile ( i 3 n ) do
int nJ :$ 1! // n/ di %ia))i c7e posso *are ac+uistando un a&&ona#ento i )iorno ).i1
int A8a. :$ g,i- % 2F! // scaden$a a&&ona#ento ac+uistato i )iorno ).i1
int 0 :$ i%1!
)hile ( 0 3 n and g,0- 3 A8a. ) do
nJ :$ nJ%1!
0 :$ 0%1!
end)hile
// n% ( i nu#ero di %ia))i c7e posso *are con un a&&ona#ento ac+uistato i )iorno
).i1
// ).:1 ( i )iorno de pri#o %ia))io successi%o aa scaden$a de!a&&ona#ento
ac+uistato i )iorno ).i1
// #i con%iene un a&&ona#ento oppure n% &i)ietti sin)oiD
if ( nJ # ) I A ) then
print NA8[BiAto biglietto Aingolo giorno N/ g,i-
i :$ i % 1!
else
print NA8[BiAto abbonamento giorno N/ g,i-
i :$ 0!
endif
end)hile
Capitolo 7: rogrammazione
!inamica
Esercizio %.1
Bn $istri"utore $i "i"ite contiene al suo interno n onete i cui valori sono rispettivaente cS1T, cS2T, W,
cSnT. ?utti i valori sono interi positiviD possi"ile che pi- onete presenti nel $istri"utore a""iano lo stesso
valore. *i consi$eri il pro"lea $i $eci$ere se possi"ile erogare, in .ualsiasi o$o, un resto esattamente
uguale a D utilizzan$o un opportuno sottoinsiee $elle n onete a $isposizioneD D un intero positivo.
1. 1escrivere un algorito e00iciente per $eci$ere se il pro"lea aette una soluzione oppure no.
2. 1eterinare il costo coputazionale $ell'algorito $escritto al punto 1, otivan$o la risposta
3. Mo$i0icare l'algorito $i cui al punto 1 per $eterinare anche .uali sono le onete $a erogare per
pro$urre il resto D. *i noti che non necessario erogare il resto con il nuero inio $i onete(
su00iciente erogarlo in o$o .ualsiasi.
Soluzione. %n assenza $i ulteriori in0orazioni sui valori $elle onete a $isposizione, gli algoriti gree$y
non necessariaente sono in gra$o $i in$ivi$uare una soluzioneD $i conseguenza l'unica possi"ilitC $i usare
la prograazione $inaica. %l pro"lea proposto si puN ricon$urre al subset:sum (roblem..
1e0iniao la atrice "ooleana ;S1..n, 0..DT tale che ;Si, rT I true se e solo se esiste un sottoinsiee $elle
prie i onete $i valore coplessivo uguale a r.
%niziao innanzitutto a $e0inire i casi "ase. *e iI1 possiao solo scegliere se usare la pria oneta oppure
no. Quin$i possiao erogare solaente un resto pari a zero /non usan$o la oneta4 oppure pari al valore
$ella oneta, cS1T. Quin$i per ogni rI0, W, D a""iao(
;[1, r ]=
{
true se r=0 oppure r=c[1]
false altrienti
9el caso generale, aven$o i J 1 onete a $isposizione per erogare un resto r ci sono $ue possi"ilitC(
1. *e r K cSiT allora possiao $eci$ere $i usare o eno la i#esia oneta. *e la usiao, possiao
erogare il resto r se e solo se possiao erogare r V cSiT usan$o un sottoinsiee $elle rianenti i#1
onete, cio se ;Si#1, r#cSiTT true. *e $eci$iao $i non usare la oneta i#esia, il resto r
eroga"ile se e solo se r eroga"ile usan$o un sottoinsiee $elle restanti i#1 onete, ossia se ;Si#1,
rT true.
2. *e r Q cSiT, non possiao usare la oneta i#esia perchO il suo valore superiore alla soa $a
erogare. Quin$i il resto eroga"ile se e solo se lo utilizzan$o le rianenti i#1 onete.
Quin$i possiao $e0inire ;Si, rT, per iI2, W, n% rI0, W, D coe(
;[ i % r ]=
{
;[ i1, r ];[ i1, rc[i ]] se rc[i ]
; [i1, r] altrienti
%l nostro pro"lea $i partenza /$eci$ere se possiao erogare il resto D usan$o un sottoinsiee $elle n
onete4 aette soluzione se e solo se ;Sn, DT I true. %l calcolo $i tutti gli eleenti $ella atrice ;Si, rT
A0 Capitolo 8( &rograazione 1inaica 63MM!
puN essere e00ettuato in tepo /nD4 usan$o il consueto schea $i prograazione $inaica(
algoritmo '&)+*( arra" 8,1..n- .i int/ int ' ) #ool
arra" M,1..n/ 0..'- .i #ool!
// ini$iai$$a ;.1' r1
for r:$0 to ' do
if ( r $$ 0 SS r $$ 8,1- ) then
M,1/ r- :$ trBe!
else
M,1/ r- :$ @alAe!
endif
endfor
// cacoa i restanti ee#enti dea ta&ea
for i :$ 2 to n do
for r :$ 0 to ' do
if ( r 8,i- ) then
M,i/ r- :$ M,i"1/ r- SS M,i"1/ r"8,i--!
else
M,i/ r- :$ M,i"1/ r-!
endif
endfor
endfor
return M,n/ '-!
&er $eterinare le onete $a usare, 0acciao ricorso a$ una ulteriore atrice "ooleana LSi, rT, avente la
stessa $iensione $i ;. LSi, rT II true se e solo se usiao la oneta i#esia per erogare il resto r. 3ccorre
prestare attenzione ai casi in cui iI1( LS1, rT false se rI0, in .uanto non usiao alcuna oneta per erogare
il resto zero, entre true se r I cS1T. @li eleenti $i L possono essere calcolati conteporaneaente a
.uelli $ella atrice ;, coe segue(
algoritmo '&)+*MAQM*N&+&( arra" 8,1..n- .i int/ int ' ) #ool
arra" M,1..n/ 0..'- .i #ool!
arra" U,1..n/ 0..'- .i #ool!
// ini$iai$$a ;.1' r1 e E.1' r1
for r:$0 to ' do
if ( r $$ 8,1- ) then
M,1/ r- :$ trBe!
U,1/ r- :$ trBe!
elseif ( r $$ 0 ) then
M,1/ r- :$ trBe!
U,1/ r- :$ @alAe!
else
M,1/ r- :$ @alAe!
U,1/ r- :$ @alAe!
endif
endfor
// cacoa i restanti ee#enti dee ta&ee
for i:$2 to n do
for r :$ 0 to ' do
if ( r 8,i- ) then
M,i/ r- :$ M,i"1/ r- SS M,i"1/ r"8,i- -!
U,i/ r- :$ M,i"1/ r"8,i- -!
else
M,i/ r- :$ M,i"1/ r-!
U,i/ r- :$ @alAe! // non usia#o a #oneta i-esi#a
endif
endfor
endfor
if ( M,n/ '- $$ trBe ) then
A1
int i :$ n!
int r :$ '!
)hile ( r 1 0 ) do
if ( U,i/ r- $$ trBe ) then
print NBAo la monetaP i!
r :$ r " 8,i-!
endif
i :$ i " 1!
end)hile
else
print NneAABna AolBzioneP!
endif
return M,n/ '-!
Esercizio %.2
*upponiao $i avere n 0iles aventi rispettivaente $iensione /S1T, /S2T, W, /SnTD le $iensioni sono
nueri interi strettaente positivi e sono espresse in M6. 1isponiao $i un C1#<3M avente capacitC
>50M6D s0ortunataente, il C1#<3M potre""e non essere su00icienteente capiente per eorizzare tutti
gli n 0iles.
1. *crivere un algorito e00iciente per $eterinare il numero massimo di files che possi"ile
eorizzare sul C1#<3M senza ecce$erne la capacitC. 9on richiesto che l'algorito stapi anche
.uali 0ile eorizzare.
2. !nalizzare il costo coputazionale $ell'algorito proposto.
Soluzione. Questo pro"lea si puo' risolvere sia utilizzan$o la prograazione $inaica, che e$iante una
tecnica gree$y.
]olen$o utilizzare la prograazione $inaica, $e0iniao la atrice $i interi ;S1..n, 0..>50T tale che ;Si, jT
rappresenta il assio nuero $i 0ile, scelti tra [1% O% i\, che possi"ile copiare su un supporto $i capacitC
j M6. &er ogni jI0, W, >50 possiao porre(
;[1, j ]=
{
1 se j/ [1]
0 altrienti
%n generale, l'eleento ;Si, jT, per i I 2, W n, jI0, W, >50 puN essere calcolato coe(
;[ i % j ]=
{
ma?( ;[ i1, j ] % ; [i1, j /[i ]]+1) se j/[i ]
;[i1, j ] altrienti
%n altre parole( se la $iensione /SiT $el 0ile i#esio supera la capacitC j, il 0ile non puN essere copiato e
.uin$i ;Si, jT (I ;Si#1, jT. %nvece, se /SiT inore o uguale alla capacitC j, occorre scegliere se copiare il 0ile
oppure no. *e $eci$iao $i non copiarlo, il nuero $i 0iles sarC ;Si#1, jT. *e $eci$iao $i copiarlo, il
nuero $i 0iles sarC 1E;Si#1, j#/SiTT. ,a scelta corretta .uella che assiizza il nuero $i 0iles sul
supporto.
,'algorito puN essere $escritto con lo pseu$oco$ice seguente(
algorithm MAQNUMF:2&)D:NAM:;A( arra" F,1..n- .i int ) int
arra" M,1..n/ 0..5G0- .i int!
// ini$iai$$a ;.1' :1
for 0 :$ 0 to 5G0 do
if ( 0 X F,1- ) then
M,1/ 0- :$ 1!
else
M,1/ 0- :$ 0!
endif
A2 Capitolo 8( &rograazione 1inaica 63MM!
endfor
// 4ie#pi i resto dea #atrice
for i :$ 2 to n do
for 0 :$ 0 to 5G0 do
if ( 0 X F,i- ?? M,i " 1/ 0 7 F,i-- % 1 1 M,i " 1/ 0- ) then
M,i/ 0- :$ M,i " 1/ 0 " F,i-- % 1!
else
M,i/ 0- :$ M,i"1/ 0-!
endif
endfor
endfor
return M,n/ 5G0-!
%l costo coputazionale /n >504 I /n4 />50 una costante che non $ipen$e $al nuero $i 0iles, .uin$i
puN essere oessa $alla notazione asintotica4.
&ossiao ottenere il risultato corretto /e ottio4 usan$o una tecnica gree$y. ,'i$ea $i or$inare i 0iles in
or$ine non $ecrescente in "ase alla $iensione. 2atto .uesto, copiao sul C1#<3M i 0iles a partire $a
.uello $i $iensione inore, 0ino a .uan$o c' spazio.
algoritmo MAQNUMF:2&)('&&DC( arra" F,1..n- .i int ) int
*'D:NA;'&);&N+&(F)!
i :$ 1! // cursore su!arra" -
D :$ 5G0! // spa$io disponi&ie' ini$ia#ente FG@;B
)hile ( i 3 n ?? D X F,i- ) do
D :$ D 7 F,i-!
i :$ i%1!
end)hile
return i"1!
*i noti il controllo Gi L nH che $eve essere e00ettuato per evitare $i acce$ere all'eleento /SnE1T che non
esisteD .uesto si veri0ichere""e nel caso in cui la soa $elle $iensioni $i tutti i 0iles sia inore o uguale a
>50, e .uin$i tutti i 0iles possano essere eorizzati nel C1#<3M.
%l costo coputazionale $i MAQNUMF:2&)('&&DC $oinato $all'operazione $i or$inaento, che puN essere
realizzata in tepo 3/n log n4 utilizzan$o un algorito $i or$inaento generico, a$ esepio M&'(&)*'+.
*0ruttan$o il 0atto che l'array /S1..nT un array $i interi, sare""e anche possi"ile utilizzare un algorito $i
or$inaento pi- e00iciente che operi in tepo lineare.
Esercizio %.3
Bna eittente televisiva $eve $eci$ere .uali spot an$are in on$a $urante un intervallo pu""licitario $ella
$urata $i T secon$i. ,'eittente $ispone $i n J 1 spot pu""licitariD per ogni iI1, 2, ... n, sia tSiT la $urata /in
secon$i4 $ello spot i#esio, e ,SiT il prezzo che l'inserzionista paga all'eittente se viene an$ato in on$a lo
spot i#esio. ,'eittente puN an$are in on$a un sottoinsiee $egli n spot a $isposizione, purchO la $urata
coplessiva non superi T secon$i. Ciascuno spot puN essere an$ato in on$a al assio una volta. ?utte le
$urate sono nueri interi.
1. 1escrivere un algorito e00iciente per calcolare il gua$agno assio otteni"ile $all'eittente
an$an$o in on$a un opportuno sottoinsiee $egli n spot. %l gua$agno coplessivo rappresentato
$alla soa $ei prezzi ,SiT $egli spot an$ati in on$a. Z richiesto il calcolo $ella soluzione esatta
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
3. Mo$i0icare l'algorito $i cui al punto 1 per restituire, oltre al gua$agno assio, anche l'elenco
$egli spot $a an$are in on$a per assiizzare il gua$agno.
Esercizio %.
1isponiao $i un tu"o etallico $i lunghezza =. 1a .uesto tu"o vogliao ottenere al pi- n segenti pi-
corti, aventi rispettivaente lunghezza lunS1T, lunS2T, W, lunSnT% che possiao riven$ere al prezzo
A3
rispettivaente (S1T, (S2T, W, (SnT. %l tu"o viene segato sepre a partire $a una $elle estreitC, .uin$i ogni
taglio ri$uce la sua lunghezza $ella isura asportata. ?utte le lunghezze sono espresse in c, e sono intere.
1. *crivere un algorito e00iciente per $eterinare il assio ricavo che possi"ile ottenere
su$$ivi$en$o opportunaente il tu"o $i lunghezza =. 9on necessario utilizzare l'intero tu"o.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. *ia DSi, jT il ricavo assio che possi"ile ottenere $a un opportuno sottoinsiee $ei segenti
[1, W, i\ a partire $a un tu"o $i lunghezza j, con iI1, W, n, jI0, W, =. ,a soluzione al pro"lea sarC .uin$i
il valore $i DSn, =T.
!ven$o solo il prio segento a $isposizione, per ogni jI0, W, = possiao scrivere(
D[1, j ]=
{
([1] se jlun[1]
0 altrienti
%n generale per ogni iI2, W, n, jI0, W, = si ha(
D[i % j]=
{
ma? ( D[i1, j ] % D[i1, jlun[i ]]+([i ]) se jlun[i ]
D[i1, j ] altrienti
,o pseu$oco$ice $ell'algorito il seguente.
algoritmo +A(2:A+U6:( arra" lBn,1..n- .i int/ arra" p,1..n- .i dou#le ) dou#le
arra" ',1..n/ 0..2- .i dou#le
// Ini$iai$$a 4.1' :1
for 0:$0 to 2 do
if ( 0 X lBn,1- ) then
',1/ 0- :$ p,1-!
else
',1/ 0- :$ 0!
endif
endfor
// Cacoo ta&ea di pro)ra##a$ione dina#ica
for i:$2 to n do
for 0:$0 to 2 do
if ( 0 X lBn,i- ?? ',i"1/ 0- I ',i"1/ 0"lBn,i-- % p,i- ) then
',i/ 0- :$ ',i"1/ 0"lBn,i-- % p,i-!
else
',i/ 0- :$ ',i"1/ 0-!
endif
endfor
endfor
return ',n/ 2-!
%l costo coputazionale $ell'algorito /n=4.
Esercizio %.!
1ovete a00rontare l'esae $i 2ilologia 6izantina. ,'esae si copone $i n $oan$e che valgono
rispettivaente (S1T% O% (SnT punti. %n "ase alla vostra esperienza, stiate che le $oan$e richie$eranno
rispettivaente tS1T, W, tSnT inuti per essere svolte. &urtroppo il tepo a vostra $isposizione $i T inuti,
che potre""e essere in0eriore alla soa $ei tepi necessari a rispon$ere a tutte le $oan$e. % punteggi e i
tepi sono interi strettaente positivi.
1. *crivere un algorito e00iciente che, $ati i vettori (S1..nT, tS1..nT e il valore $i T, restituisce il
punteggio assio che potete ottenere rispon$en$o correttaente a$ un opportuno sottoinsiee
$elle n $oan$e entro il tepo assio $i T inuti. 9ota( non richiesto $i calcolare
esplicitaente .uali sono le $oan$e che consentono $i ottenere il punteggio assio.
A4 Capitolo 8( &rograazione 1inaica 63MM!
2. Calcolare il costo coputazionale $ell'algorito $i cui al punto 1
Soluzione. *ia ,Si, jT il punteggio assio che possi"ile ottenere rispon$en$o correttaente a$ un
opportuno sottoinsiee $elle $oan$e [1, W, i\ aven$o a $isposizione il tepo assio $i j inuti, per
iI1, W, n, jI0, W, T. ,a soluzione al pro"lea sarC .uin$i il valore $i ,Sn, TT.
,a ta"ella $i prograazione $inaica cosa $e0inita. &er ogni jI0, W T si ha
,[1, j]=
{
([1] se jt [ 1]
0 altrienti
e per ogni iI2, W n% jI0, W T(
,[i % j ]=
{
ma? { ,[i1, j] % ,[i1, jt [i ]]+ ([i ]} se jt [ i]
,[i1, j ] altrienti
per ogni iI2, W, n, jI0, W, T
,'algorito risolutivo puN .uin$i essere espresso in .uesto o$o(
algoritmo F:2*2*(:A6:MAN+:NA( arra" p,1..n- .i int/ arra" t,1..n- .i int/ int + ) int
arra" >,1..n/ 0..+- .i int
// Ini$iai$$a P.1' :1
for 0:$0 to + do
if ( 0 X t ,1- ) then
>,1/ 0- :$ p,1-!
else
>,1/ 0- :$ 0!
endif
endfor
// Cacoo ta&ea di pro)ra##a$ione dina#ica
for i:$2 to n do
for 0:$0 to + do
if ( 0 X t,i- ?? >,i " 1/ 0- I >,i " 1/ 0 " t,i-- % p,i- ) then
>,i/ 0- :$ >,i " 1/ 0 " t,i-- % p,i-!
else
>,i/ 0- :$ >,i " 1/ 0-!
endif
endfor
endfor
return >,n/ +-!
%l costo $ell'algorito /nT4.
Esercizio %.$
!llo scopo $i prepararvi a$eguataente all'esae $i !lgoriti e *trutture 1ati, $eci$ete $i $e$icare 3 ore
/1A0 inuti4 per ripassare gli argoenti $el corso. 1urante il corso sono stati trattati n argoenti, e stiate
che il tepo necessario per ripassare l'argoento i#esio sia $i TSiT inutiD tutti i tepi sono nueri interi.
%noltre, a$ ogni argoento i associate un nuero reale positivo .SiT che ne $enota l'iportanza /aggiore
il valore .SiT, pi- iportante l'argoento4. *crivere un algorito e00iciente per $eterinare l'iportanza
coplessiva assia $egli argoenti che potete ripassare entro i 1A0 inuti a vostra $isposizione. 9on
richiesto $i in$icare anche .uali sono gli argoenti che assiizzano l'iportanza.
Esercizio %.%
*i consi$eri un array AS1..nT coposto $a n nueri reali $istinti, non or$inato. *i vuole $eterinare la
assia lunghezza $i una sottose.uenza $i A coposta $a eleenti in or$ine crescente. 9on richiesto che
A5
la sottose.uenza sia coposta $a eleenti contigui.
!$ esepio, supponen$o che AIS4, 1,#1,3, 10, 11T, possi"ili sottose.uenze coposte $a valori crescenti sono
S1, 3, 11T, oppure S4, 10, 11T, oppure S1, 3, 10, 11T /si noti che i valori vanno consi$erati nell'or$ine in cui
copaiono in A4. 9el caso $ell'array $i esepio, l'algorito $eve restituire il valore 4 in .uanto la pi- lunga
sottose.uenza $i valori crescenti ha lunghezza 4 /in particolare S1, 3, 10, 11T oppure S#1, 3, 10, 11T sono $ue
sottose.uenze $i lunghezza assia4.
1. *crivere un algorito "asato sulla prograazione $inaica per calcolare la assia lunghezza $i
una sottose.uenza crescente. /*uggeriento( sia =SjT la assia lunghezza $i una sottose.uenza
crescente $i AS1..jT avente ASjT coe ultio eleento4
2. Calcolare il costo coputazionale $ell'algorito $i cui al punto prece$ente.
Soluzione. *0ruttiao il suggeriento. 9otiao innanzitutto che =S1T I 1, poichO la sottose.uenza coposta
$al singolo eleento AS1T crescente, e ha lunghezza 1. &er calcolare il generico valore =SjT, aven$o giC
calcolato =S1T, ,S2T, W, =Sj#1T ragioniao coe segue( la pi- lunga sottose.uenza crescente $i AS1..jT che
terina in ASjT avrC un penultio eleento ASkT, per un certo k Q j. Quin$i la pi- lunga sottose.uenza che
terina in ASjT sarC coposta $a un prio pezzo $i lunghezza =SkT, che ha ASkT coe ultio eleento, a cui
si aggiunge ASjT. Quin$i =SjT I =SkT E 1. %l pro"lea che non sappiao .uale sia il valore $i k corretto.
;sainiao .uin$i tutti i valori $i k Q j per cui si veri0ica ASkT Q ASjT /ricor$iao che gli eleenti $ella
sottose.uenza $evono essere or$inati in senso crescente4, e tra .uesti valori scegliao .uello per cui =SkT
assio. 9el caso in cui non esistano valori $i k che so$$is0ano le con$izioni sopra, il assio viene posto
a zero.
%l calcolo $i =SjT si puN e00ettuare con la seguente e.uazione(
=[ j ]=
{
1 se j=1
1+ma?
1k< j % A[k]<A[ j ]
=[ k ] altrienti
Bna volta calcolato =SjT per ogni jI1, W, n, il valore richiesto $al pro"lea il assio tra tutti gli =SjT.
%n0atti, non sappiao .uale sia l'ultio eleento $ella sottose.uenza crescente $i lunghezza assia, per
cui $o""iao esainarle tutte.
algoritmo MAQ2UN)*++*)&9U&NMA( arra" A,1..n- .i dou#le ) int
// Pri#a *ase2 cacoa L.:1 per o)ni :
arra" 2,1..n- .i int!
2,1- :$ 1!
int 2maL :$ 2,1-! // lBnghezza maAAima .i Bna AottoAe[Benza 8reA8ente
for 0:$2 to n do
int maLlBn :$ 0!
for 4:$1 to 0"1 do
if ( A,4- I A,0- ?? 2,4- 1 maLlBn ) then
maLlBn :$ 2,4-!
endif
endfor
2,0- :$ 1 % maLlBn!
if ( 2,0- 1 2maL ) then
2maL :$ 2,0-!
endif
endfor
return 2maL!
9otiao che il corpo $el ciclo 0or pi- interno 0ase ha costo 3/14, e viene eseguito 1 E 2 E W E / n#24 E /n#14
I /n
2
4 volte, per cui il costo coplessivo $ell'algorito /n
2
4.
Esercizio %.&
*ono $ati $ue array AS1..nT e .S1..nT coposti $a n K 2 nueri reali positivi. ASiT e .SiT rappresentano
rispettivaente il prezzo unitario $i ac.uisto e $i ven$ita $elle azioni $i una certa societC al giorno i.
A> Capitolo 8( &rograazione 1inaica 63MM!
]ogliao in$ivi$uare $ue giorni i Q j tali $a assiizzare il gua$agno unitario /o iniizzino la per$ita
unitaria4 otteni"ile ac.uistan$o una azione il giorno i e riven$en$ola il giorno j. Z possi"ile ven$ere solo $al
giorno successivo all'ac.uisto in poiD consentito un singolo ac.uisto e una singola ven$ita.
1. *crivere un algorito che, $ati in input i vettori A e ., $eterini i valori $i i e j che assiizzano il
gua$agno unitario.
2. !nalizzare il costo coputazionale $ell'algorito proposto
Soluzione. Bna soluzione non e00iciente, a corretta, consiste nel controllare tutte le co"inazioni possi"ili(
algoritmo ;*M>'AW&ND:1( arra" A,1..n- .i dou#le/ arra" W,1..n- .i dou#le ) (int/ int)
dou#le (maL :$ W,2- " A,1-!
int imaL :$ 1!
int 0maL :$ 2!
for i:$1 to n"1 do
for 0 :$ i % 1 to n do
if ( W,0- 7 A,i- 1 (maL ) then
(maL :$ W,0- 7 A,i-!
imaL :$ i!
0maL :$ 0!
endif
endfor
endfor
return imaL/ 0maL!
%l costo $i .uesto algorito /n
2
4D iportante osservare che /14 inizializzare (maL /il valore $el
gua$agno assio4 con 0 sare""e stato s"agliato, in .uanto l'algorito non avre""e 0ornito la risposta
corretta nel caso in cui tutti i gua$agni 0ossero stati negativi /ossia tutte le possi"ili transazioni si
conclu$evano in per$ita4D /24 $ienticarsi $i inizializzare imaL e 0maL 0uori $ai cicli 0or sare""e stato
ugualente s"agliato, in .uanto in tal caso l'algorito avre""e restituito valori in$e0initi nel caso nI2.
%l pro"lea aette una soluzione pi- e00iciente, che richie$e tepo lineare nella $iensione $egli array A
e .. Bna variante che richie$e tepo /n4 e spazio aggiuntivo /14 la seguente(
algoritmo ;*M>'AW&ND:2( arra" A,1..n- .i dou#le/ arra" W,1..n- .i dou#le ) (int/ int)
dou#le (maL :$ W,2- " A,1-! // )uada)no #assi#o
int a8 :$ 1!
int Je :$ 2!
int imin :$ 1! // A.i#in1 ( i #ini#o pre$$o di ac+uisto in A.1//:-11
for 0:$2 to n do
if ( W,0- 7 A,imin- 1 (maL ) then
(maL :$ W,0- 7 A,imin-!
a8 :$ imin!
Je :$ 0!
endif
if ( A,0- I A,imin- ) then
imin :$ 0!
endif
endfor
return imin/ 0maL!
Questo algorito e00ettua una singola scansione $egli array, utilizzan$o tre cursori( a8 e Je in$icano, coe
pria, gli in$ici $ei giorni in cui ac.uistare e ven$ere, rispettivaente. %n pi-, viene utilizzato un ulteriore
cursore imin, che ha il signi0icato seguente( all'inizio $i ogni iterazione $el ciclo 0or, ASiminT il valore
inio $el sottovettore AS1..j # 1T. %n altre parole, se $eci$essio $i ven$ere il giorno j, il valore $i ac.uisto
pi- "asso in tutti i giorni prece$enti sare""e ASiminT in corrispon$enza $el giorno imin. &ertanto, volen$o
ven$ere il giorno j, otterreo il assio gua$agno .SjT V ASiminT. ac.uistan$o al giorno imin. *e tale
gua$agno superiore al assio osservato 0ino a .uel oento, aggiorniao i cursori.
A8
Esercizio %.'
1opo l'ennesio auento ingiusti0icato $elle tasse, avete $eciso $i a$ottare una 0ora $i protesta non
violente che consiste nel pagare l'iporto $ovuto interaente in onetine. ]i recate .uin$i presso la vostra
"anca per ca"iare $elle "anconote, ottenen$o in ca"io un grosso sacchetto contenente n onete i cui
valori, espressi in centesii $i euro, sono rispettivaente cS1..nT. &er ren$ere ancora pi- signi0icativa la
vostra protesta, $eci$ete $i erogare l'iporto $ovuto $i tasse, pari a D centesii, usan$o il massimo nuero
possi"ile $i onete. % valori $elle onete e l'iporto D sono tutti interi strettaente positivi.
*crivere un algorito che, $ato in input l'array c e il valore D, calcoli il assio nuero $i onete che sono
necessarie per erogare un iporto esattaente pari a D, aesso che ciN sia possi"ile. !nalizzare il costo
coputazionale $ell'algorito proposto.
Soluzione. &er risolvere .uesto pro"lea si potre""e essere tentati $i utilizzare un approccio gree$y
GinversoH rispetto a .uello a$ottato per risolvere il pro"lea $el resto, ossia $i or$inare i valori $elle onete
in senso crescente, e$ erogare le onete $i valore inore.
algoritmo MAQNUMM*N&+&)6A(2:A+*( arra" 8,1..n- .i int/ int ' ) int
*'D:NA;'&);&N+&(8)!
int i :$ 1! // indice dea #oneta c7e stia#o considerando
)hile ( ' 1 0 ?? i 3 n ) do
if ( 8,i- 1 ' ) then
errore: reAto non erogabile!
else
' :$ ' 7 8,i-!
i :$ i%1!
endif
end)hile
if ( ' 1 0 ) then
errore: reAto non erogabile!
else
return i"1! // a&&ia#o utii$$ato e pri#e i-1 #onete
endif
&urtroppo tale approccio non 0unziona( consi$eriao in0atti i valori seguenti /l'array giC or$inato4( c I S1,
2, 2, 2, 5T. 1oven$o erogare un iporto DI>, 0acile convincersi che il assio nuero $i onete richiesto
3 /servono le tre onete $a 24. ,'algorito MAQNUMM*N&+&)6A(2:A+* invece scegliere""e su"ito la oneta
$a 1, poi $ue onete $a 2 e a .uel punto non sare""e pi- in gre$o $i erogare il resi$uo $i 1 centesio.
Btilizziao .uin$i la prograazione $inaica. *ia JSi, rT il assio nuero $i onete scelte tra l'insiee
[1, W, i\ che sono necessarie per erogare un iporto esattaente pari a r /per ogni iI1, W, n% rI0, W, D4D se
non possi"ile erogare r, poniao JSi, rT I #.
!ven$o solo la pria oneta a $isposizione /iI14 a""iao(
J [1, r]=
{
0 se r=0
1 se r=c[1]
altrienti
9el caso pi- generale,, il calcolo $i JSi, rT si e00ettua coe(
J [i % r]=
{
ma? { J [i1, r ] % 1+J [ i1, rc[i ]]} se rc[i ]
J [i1, r ] altrienti
%n altre parole, se l'iporto $a erogare inore $el valore cSiT $ella i#esia oneta, allora l'iporto r $ovrC
essere erogato usan$o solo le rienenti onete [1, W i # 1\. *e r aggiore o uguale a cSiT, allora a""iao
$ue possi"ilitC( erogare r senza usare la oneta i#esia, oppure usare usare la oneta i#esia, e$ erogare la
soa resi$ua r#cSiT e$iante le rianenti onete [1, W, i # 1\.
,'algorito puN essere $escritto nel o$o seguente(
AA Capitolo 8( &rograazione 1inaica 63MM!
algoritmo MAQNUMM*N&+&( arra" 8,1..n- .i int/ int ' ) int
arra" N,1..n/ 0..'- .i int!
// Cacoa N.1' r1
for r:$0 to ' do
if ( r $$ 0 ) then
N,1/ r- :$ 0!
elseif ( r $$ 8,1- ) then
N,1/ r- :$ 1!
else
N,1/ r- :$ ":NF!
endif
endfor
// Cacoa ta&ea di pro)ra##a$ione dina#ica
for i:$2 to n
for r:$0 to ' do
// NOTA2 si ric7iede c7e (1 > -IN-) ?? -IN-
if ( r X 8,i- ?? N,i " 1/ r- I 1%N,i " 1/ r " 8,i-- ) then
N,i/ r- :$ 1 % N,i " 1/ r 7 8,i--!
else
N,i/ r- :$ N,i " 1/ r-!
endif
endfor
endfor
return N,n/ '-!
,'uso $el valore #%92 tra gli eleenti $ella atrice JSi, rT richie$e una certa attenzioneD in0atti necessario
che l'eventuale linguaggio $i prograazione usato nell'ipleentazione $ello pseu$oco$ice prece$ente
garantica che 1 E /#%924 I #%92. %n Fava /e olti altri linguaggi che supportano l'aritetica in virgola o"ile
secon$o lo stan$ar$ %;;; 8544 possi"ile usare la costante DoBble.N&(A+:W&T:NF:N:+C $e0inita nella
classe DoBble che ha esattaente le proprietC richieste. 9aturalente in .uesto caso "isognere""e $e0inire la
atrice JSi, rT coe atrice $i DoBble anzichO $i interi.
%l costo coputazionale /Dn4
Esercizio %.1(
Bn gruppo $i nJ0 persone $eve salire su un ascensore che puN sostenere un peso assio $i P 7g.
%n$ichiao con (S1T, W (SnT i pesi /in 7g4 $elle n persone. ?utti i pesi sono nueri interi.
1. *crivere un algorito per $eterinare se esiste o eno un opportuno sottoinsiee $i persone il cui
peso coplessivo sia esattamente uguale alla capacitC $ell'ascensore P /non richiesto $i in$icare
anche .uali persone 0are""ero parte $i tale gruppo4.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Esercizio %.11
Bna eittente televisiva $eve organizzare il palinsesto $i una $eterinata giornata. ,a giornata si copone
$i 1440 inuti /pari a 24 ore4. ,'eittente $ispone $i una lista $i nK1 prograi le cui $urate in inuti sono
rispettivaente dS1T, W, dSnT. ?utti i tepi sono nueri interi.
1. *crivere un algorito che restituisca true se e solo se esiste un opportuno sottoinsiee $egli n
prograi la cui $urata coplessiva sia esattaente $i 1440 inuti.
2. !nalizzare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. %l pro"lea si risolve e$iante la prograazione $inaica. 1e0iniao una atrice $S1..n,
0..1440T, tale che $Si, jT I true se e solo se esiste un .ualche sottoinsiee $ei prii i prograi [1, W, i\ la
cui $urata coplessiva sia esattaente j.
*e iI1 a""iao che $Si, jT I true se e solo se j I dS1T oppure j I 0. &er ogni iI2, W n, jI0, W 1440, gli altri
eleenti $ella atrice sono $e0initi in .uesto o$o(
A:
$[i % j ]=
{
$[ i1, j ]$[ i1, jd[ i]] se jd [i]
$[ i1, j ] altrienti
&er occupare un tepo j con un opportuno sottoinsiee $ei prograi [1, W, i\ possiao( /i4 riepire il
tepo j senza il prograa i#esio, nel caso in cui la $urata $el prograa i#esio superi j, oppure /ii4
scegliere se usare o eno il progaa i#esio nella nostra allocazione.
Quin$i l'algorito calcola tutti i valori $Si, jT, e restituisce $Sn, 1440T coe soluzione.
algoritmo >A2:N)&)+*(arra" .,1..n- .i int ) #ool
arra" 6,1..n/ 0..1440- .i #ool!
// Ini$iai$$ia#o B.1' :1
for 0:$0 to 1440 do
if ( 0 $$ 0 SS 0 $$ .,1- ) then
6,1/ 0- :$ trBe!
else
6,1/ 0- :$ @alAe!
endif
endfor
// 4ie#pia#o a #atrice B
for i:$2 to n do
for 0:$0 to 1440 do
if ( 0 X .,i- ) then
6,i/ 0- :$ 6,i"1/ 0- SS 6,i"1/ 0".,i--!
else
6,i/ 0- :$ 6,i"1/ 0-!
endif
endfor
endfor
return 6,n/ 1440-!
%l costo $ell'algorito /n14404 I R/n4
Esercizio %.12
*upponiao $i voler in$ovinare un nuero scelto $a un avversario all'interno $ell'insiee [1, 2, ..., n\. 3gni
nostro tentativo s"agliato ci costa un nuero $i GgettoniH pari al valore $el nuero che a""iao scelto. &er
ogni tentativo, l'avversario ci puN rispon$ere in uno $i .uesti tre o$i(
1. G%l nuero che hai scelto .uello correttoH.
2. G%l nuero che hai scelto aggiore $i .uello che ho in ente ioH.
3. G%l nuero che hai scelto inore $i .uello che ho in ente ioH.
*crivere un algorito per $eci$ere, a$ ogni turno, .uale il nuero pi- conveniente $a scegliere in o$o $a
iniizzare il costo totale nel caso peggiore. /*i noti che nel caso in cui il costo $i ogni tentativo 0osse
unitario, la soluzione consistere""e nell'usare l'algorito $i ricerca "inaria. 9el nostro caso tale algorito
non necessariaente pro$urre""e la se.uenza $i scelte $i costo inore nel caso pessio4.
Soluzione. Questo pro"lea olto siile a .uello $ella parentesizzazione ottia visto a lezione.
*upponiao $i in$icare con <Si, jT il costo inio /nel caso peggiore4 necessario per in$ovinare un nuero
nell'insiee [i, ..., j\. Chiaraente, <Si, iT I 0 per ogni iI1, ..., n /per in$ovinare un nuero in un insiee
coposto $a un solo nuero non ci sono scelte $a copiere4. &er calcolare <Si, jT in generale, $e0iniao una
0unzione f/i, j, k4 aggiuntiva, che rappresenta il costo ottio necessario per in$ovinare un nuero
nell'insiee [i, ..., j\ assuen$o $i usare k coe tentativo iniziale.
f (i % j % k)=
{
k+<[k +1, j ] se k=i
k +ma?(< [i % k 1] % <[ k+1, j ]) se i <k< j
<[i % k1]+k se k=j
:0 Capitolo 8( &rograazione 1inaica 63MM!
$a cui possiao $e0inire <Si, jT, per i Q j, coe(
<[i % j]=min{ f (i % j % k) % k=i % ... % j }
!llo scopo $i sapere .uali sono le GosseH igliori $a 0are /cio .uali nueri conviene selezionare nei vari
tentativi4, si puN usare un'altra ta"ella sel tale che selSi, jT rappresenta l'intero k appartenente a [i, ..., j\ $a
usare coe prio tentativo per in$ivi$uare un nuero copreso in .uell'intervallo. @li eleenti $i selSi, jT
vanno riepiti con il valore $i k che iniizza i valori $i <Si, jT.
&er garantire che a$ ogni passo tutti i valori necessari a calcolare <Si, jT siano giC stati calcolati, gli eleenti
$i C vanno calcolati secon$o lo schea seguente /le celle in grigio non vengono calcolate4(
;sepio, con nI5(
Matrice <Si, jT
0 1 2 4 >
# 0 2 3 >
# # 0 3 4
# # # 0 4
# # # # 0
atrice selSi, jT
1 1 2 1 2
2 2 3 2
3 3 4
4 4
5
algoritmo )+'A+&(:A*++:MA( int n )
arra" Ael ,1..n/ 1..n- .i int!
arra" ;,1..n/ 1..n- .i int!
// ini$iai$$a$ione de)i ee#enti dia)onai si C.1 e se.1
for i :$ 1 to n do
;,i/ i- :$ 0!
:1
Ael,i/ i- :$ i!
endfor
// cacoia#o i %aori C.i' :1 usando a pro)ra##a$ione dina#ica
for 0:$2 to n do
for i :$ 0 " 1 do)nto 1 do
int Jal!
;,i/ 0- :$ %in@! // ini$iai$$a$ione a >in*inito
for 4 :$ i to 0 do
if ( 4 $$ i ) then
Jal $ 4%;,4%1/ 0-!
elseif ( 4 $$ 0 ) then
Jal :$ ;,i/ 4"1- % 4!
else
Jal :$ 4 % maL( ;,i/ 4"1-/ ;,4%1/ 0- )!
endif
if ( Jal I ;,i/ 0- ) then
;,i/ 0- :$ Jal!
Ael,i/ 0- :$ 4!
endif
endfor
endfor
endfor
Esercizio %.13
Consi$eriao n K 1 $ischi etichettati coe [1, 2, ... n\. %l $isco i ha $iaetro dSiTD tutti i $iaetri sono
nueri reali positivi $istinti, a i $ischi non sono or$inati in alcun o$o. ]ogliao selezionare un
sottoinsiee $i $ischi $a ipilare uno sull'altro, rispettan$o le seguenti regole(
;' vietato posizionare un $isco pi- gran$e sopra a uno pi- piccolo / la stessa regola $elle torri $i
=anoi4D
;' vietato posizionare il $isco i sopra al $isco j se i J j.
%n altre parole, consentito solaente posizionare un $isco piccolo sopra a uno gran$e /non viceversa4, e
.uesto purchO il $isco piccolo a""ia un'etichetta strettaente in0eriore al $isco gran$e. *crivere un algorito
e00iciente in gra$o $i in$ivi$uare l'altezza assia $ella pila $i $ischi che possi"ile realizzare rispettan$o
le regole $i cui sopra. ,'algorito $eve anche esplicitaente in$icare .uali sono i $ischi $a ipilare.
!$ esepio, supponiao che i $iaetri siano 2, 5, 3, 1, A, 10. ,a pila $i altezza assia otteni"ile
coposta $ai $ischi 1, 3, 5, > /il $isco 1 sta in cia, il $isco > sta alla "ase4, $ato che dS1T I 2 Q dS3T I 3 Q
dS5T I A Q dS>T I 10.
Soluzione. Questo esercizio $el tutto siile all'esercizio 8.8 e puN essere risolto allo stesso o$o. *ia ,/i4
il sottopro"lea che consiste nell'ipilare il aggior nuero $i $ischi scelti tra [1, ... i\, rispettan$o i
vincoli $el testo, usan$o sepre il $isco i coe "ase $ella pila. 1enotiao con GSiT la soluzione $el
pro"lea ,/i4( GSiT il assio nuero $i $ischi che possono essere ipilati utilizzan$o il $isco i coe
"ase.
Chiaraente GS1T I 1. &er ogni iI2, ... n ragioniao coe segue. ,a pila $i altezza assia avente il $isco i
coe "ase si ottiene ipilan$o sopra a i un $isco j scelto tra [1, ... i#1\ tale che dSjT Q dSiT, e GSjT sia
assio possi"ile. Questo puN essere scritto nel o$o seguente(
G [i ]=1+a^{ G[ j] % j=1, ... i1, d [ j ]<d [i ]}
9el caso in cui non esista alcun valore j Q i per cui dSjT Q dSiT /.uesto il caso, a$ esepio, se i $iaetri $ei
$ischi sono presentati in or$ine $ecrescente4, allora GSiT I 1.
,'altezza assia G' $ella pila che possi"ile ottenere s0ruttan$o tutti i $ischi sarC .uin$i(
G
Q
=a^ { G [i ] % i=1, n}
:2 Capitolo 8( &rograazione 1inaica 63MM!
&er poter $eterinare i $ischi che 0anno parte $ella soluzione ottia, possiao 0are uso $i un vettore $i interi
upS1..nT. upSiT contiene l'in$ice $el $isco che viene posizionato ie$iataente sopra al $isco i per ottenere
la pila $i altezza GSiT9 upSiT vale zero se GSiT I 1.
algoritmo >:2AA2+&MMAMAQ( arra" .,1..n- .i dou#le ) int
arra" =,1..n- .i int!
arra" Bp,1..n- .i int!
=,1- :$ 1!
Bp,1- :$ 0!
int ibaAe :$ 1 ! // indice de disco c7e *un)e da &ase aa pia di ate$$a #assi#a
for i:$2 to n do
=,i- :$ 1!
Bp,i- :$ 0!
for 0:$1 to i"1 do
if ( .,0- I .,i- ?? =,0-%1 1 =,i- ) then
=,i- :$ =,0- % 1!
Bp,i- :$ 0!
endif
endfor
if ( =,i- 1 =,ibaAe- ) then
ibaAe :$ i!
endif
endfor
print N:l nBmero maAAimo .i .iA8hi impilabili \ N =,ibaAe-!
// ora sta#pia#o i disc7i dea pia di ate$$a #assi#a' partendo daa &ase
i :$ ibaAe! // i rappresenta !indice de disco
)hile (i 1 0) do
print NUAo il .iA8o N i!
i :$ Bp,i-!
end)hile
return =,n-!
!$ esepio, se il dS1..nT $e0inito coe segue, con nI>(
2 5 3 1 A 10
l'algorito calcola il seguente vettore GS1..nT $elle altezze(
1 2 2 1 3 4
e il seguente vettore $ei $ischi Gpre$ecessoriH upS1..nT(
0 1 1 0 2 5
%n realtC possi"ile ricostruire la soluzione ottia /l'elenco $ei $ischi $a ipilare4 anche senza usare il
vettore ausiliario upS1..nT, ragionan$o coe segue. *e a""iao in .ualche o$o $eterinato che il $isco i
appartiene alla soluzione ottia, proce$iao a ritroso per in$ivi$uare l'in$ice j Q i tale che GSjT I GSiT V 1.
,'in$ice j ci 0ornisce l'in$ice $el $isco posizionato ie$iataente sopra a i nella soluzione ottia.
3vviaente ci si 0era non appena si trova GSiT I 1. Questo eccaniso, se""ene consenta $i evitare l'uso
$ell'array ausiliario, ha lo svantaggio che il ciclo $i stapa $ella soluzione non "anale e va ipleentato
con cura.
algoritmo >:2AA2+&MMAMAQ( arra" .,1..n- .i dou#le ) int
arra" =,1..n- .i int!
=,1- :$ 1!
int ibaAe :$ 1 ! // indice de disco c7e *un)e da &ase aa pia di ate$$a #assi#a
:3
for i:$2 to n do
=,i- :$ 1!
for 0:$1 to i"1 do
if ( .,0- I .,i- ?? =,0-%1 1 =,i- ) then
=,i- :$ =,0- % 1!
endif
endfor
if ( =,i- 1 =,ibaAe- ) then
ibaAe :$ i!
endif
endfor
print N:l nBmero maAAimo .i .iA8hi impilabili \ N =,ibaAe-!
// ora sta#pia#o i disc7i dea pia di ate$$a #assi#a' partendo daa &ase
int 0 :$ ibaAe!
do
i :$ 0!
// i ? indice disco (parte dea sou$ione otti#a) c7e stia#o anai$$ando< : ? indice
disco (anc7!esso parte dea sou$ione otti#a) c7e %iene appo))iato i##ediata#ente
sopra a i' e c7e +uindi anai$$ere#o a prossi#o passo
print NUAo il .iA8o N i!
if ( =,i- 1 1 ) then
do
0 :$ 0 7 1!
)hile ( .,0- X .,i- SS =,0- K =,i- 7 1 )
endif
)hile (=,i- 1 1)!
return =,n-!
Esercizio %.1
*i supponga $i avere n 0iles in cui il 0ile i occupa /SiT M6. *upponiao che tutte le $iensioni /SiT siano
intere /ossia, ciascun 0ile occupa un ultiplo intero $i un M64. ]ogliao in$ivi$uare, se esiste, un
sottoinsiee $i 0ile la cui $iensione coplessiva sia esattamente (ari a >50M6. %n caso tale sottoinsiee
esista, vogliao anche sapere gli in$ici $ei 0iles che vi appartengono.
Soluzione. Consi$eriao una atrice $Si, jT $i "ooleani, per ogni iI1, ..., n e per ogni jI0, ..., >50, tali che
$Si, jT I true se e solo se esiste un sottoinsiee $ei prii i 0iles [1, ..., i\ la cui $iensione coplessiva sia
esattaente pari a j M6.
%niziao consi$eran$o i casi "ase(
$Si, 0T I true, per ogni iI1, ..., n /il sottoinsiee vuoto $i 0ile ha $iensione coplessiva pari a
zero4D
$S1, /S1TT I true, in .uanto il sottoinsiee $i [1\ coposto solo $al 0ile nuero 1 ha esattaente
$iensione /S1T. /attenzione a veri0icare che /S1T L >50, altrienti l'eleento $S1, /S1TT non
esistere""e4
&er .uanto riguar$a il generico eleento $Si, jT, possiao applicare lo stesso ragionaento che a""iao
applicato per il pro"lea $ello zaino. *peci0icaente, $Si, jT I true se e solo se vale aleno una $elle
con$izioni seguenti(
$Si#1, jT I trueD in0atti, in .uesto caso signi0ica che esiste un sottoinsiee - $ei prii i#1 0iles la cui
$iensione coplessiva j. ,o stesso sottoinsiee - anche /per $e0inizione4 un sottoinsiee $ei
prii i 0iles, .uin$i $Si, jT I trueD
$Si#1, j#/SiT T I trueD in .uesto caso, esiste un sottoinsiee $ei prii i#1 0iles la cui $iensione
coplessiva pari a j#/SiT. !ggiungen$o il 0ile i#esio, si ottiene un sottoinsiee $i 0iles in [1, ...,
i\ la cui $iensione coplessiva /j#/SiT4 E /SiT I j.
Questo signi0ica che possiao sepliceente scrivere
$[i % j ]=$[i1, j ]$[i1, j/ [i ]]
:4 Capitolo 8( &rograazione 1inaica 63MM!
Z iportante prestare attenzione al 0atto che l'espressione $Si#1, j#/SiT T puN essere calcolata solo se j K /SiT,
altrienti il secon$o in$ice $ella atrice $iventa negativo.
%n conclusione, esiste un sottoinsiee $egli n 0iles la cui $iensione esattaente pari a >50M6 se e solo se
$Sn, >50T true. &er sapere .uali 0iles 0anno parte $i tale sottoinsiee, usiao una ulteriore atrice
"ooleana ,Si, jT, tale che ,Si, jT I true se e solo se il 0ile i#esio 0a parte $ell'eventuale sottoinsiee $i [1, ...,
i\ la cui $iensione coplessiva sia esattaente pari a j /sepre se tale sottoinsiee esiste4. ,e atrici $ e
, possono essere costruite con lo pseu$oco$ice seguente(
algoritmo ;*>:A+U++*( arra" F,1..n- .i int )
arra" 6,1..n/ 0..5G0- .i #ool!
arra" >,1..n/ 0..5G0- .i #ool!
for 0 :$ 0 to 5G0 to
if ( 0 $$ 0 ) then
6,i/ 0 - :$ trBe!
>,1/ 0 - :$ @alAe!
elseif ( 0 $$ F,1- ) then
6,1/ 0 - :$ trBe!
>,1/ 0 - :$ trBe!
else
6,1/ 0 - :$ @alAe!
>,1/ 0 - :$ @alAe!
endif
endif
for i:$2 to n do
for 0:$0 to 5G0 do
if ( 0 X F,i- ?? 6,i " 1/ 0 " F,i- - $$ trBe ) then
6,i/ 0- :$ trBe!
>,i/ 0- :$ trBe! // usia#o i *ie i-esi#o
else
6,i/ 0- :$ 6,i"1/ 0-!
>,i/ 0- :$ @alAe!
endif
endfor
endfor
if ( 6,n/ 5G0- $$ trBe ) then
print N&AiAte Bna AolBzioneP
// sta#pa dea sou$ione
0 :$ 5G0!
i :$ n!
)hile ( 0 1 0 ) do
if ( >,i/ 0- $$ trBe ) then
print NUAo @ile N i!
0 :$ 0 7 F,i-!
endif
i :$ i"1!
end)hile
else
print NNon eAiAte Bna AolBzioneP
endif
Esercizio %.1!
*i consi$eri un insiee $i n persone che $evono salire su un ascensore. ,'ascensore in gra$o $i sostenere
un peso assio pari a < 7g, a su00icienteente apio $a ospitare un nuero .ualsiasi $i persone. *iano
(S1T, ... , (SnT i pesi in 7g $elle n persone. %l vettore $ei pesi non or$inato. ?utti i pesi sono interi.
*crivere un algorito che, $ati in input il valore $i < e il vettore (S1..nT, restituisca il nuero assio $i
:5
persone che possono salire sull'ascensore conteporaneaente, senza superare il peso assio coplessivo
$i < 7g. %n altre parole, si chie$e $i $eterinare la car$inalitC $i un sottoinsiee assiale $elle n persone il
cui peso coplessivo risulti inore o uguale a <. /-uggerimentoK si (uN usare la (rogramma@ione dinamica
o((ure un algoritmo greed#4. !nalizzare il costo coputazionale $ell'algorito proposto
Soluzione. ,'approccio "asato sul para$iga gree$y il pi- seplice e in .uesto caso si puN applicare per
ottenere la soluzione ottia( 0acciao entrare le persone in ascensore in or$ine non $ecrescente $i peso
/pria la persona che pesa $i eno, poi la successiva e cosa via4. Ci 0eriao esclu$en$o la pria persona
che, entran$o in ascensore, 0are""e superare la portata assia.
algoritmo A);&N)*'&('&&DC( int ;/ arra" p,1..n- .i int ) int
*'D:NA;'&);&N+&(>)!
int i :$ 1!
)hile( i3n ?? p,i- 3 ; ) do
; :$ ; " p,i-!
i :$ i%1!
end)hile
return i"1!
%l costo $ell'algorito MAQ>&')*N&('&&DC $oinato $al costo $ell'operazione $i or$inaento, ossia
3/n log n4 usan$o un algorito generico / possi"ile or$inare in tepo lineare usan$o un algorito che
s0rutta il 0atto che i pesi sono interi4.
,'approccio "asato sulla prograazione $inaica si "asa su una atrice i cui eleenti JSi, cT in$icano il
assio nuero $i persone, scelte tra le prie i, che possi"ile GstipareH in un ascensore avente portata
assia $i c fg, iI1, ..., n, cI0, ..., <. *i noti il Gassio nuero $i personeH, 939 Gassio peso $elle
personeH.
Cons$eriao il caso iI1, in cui c' solo una persona /la pria4 che puN salire. *i ha che JS1, cT I 1 se e solo
se c K (S1T( il nuero $i personc che puN salire 1 se e solo se la capacitC c $ell'ascensore aggiore o
uguale al peso (S1T $ella persona. Quin$i(
J [1, c]=
{
1 se c([1]
0 altrienti
&er calcolare JSi, cT nel caso generico, ragioniao coe segue. *e il peso $ella persona i#esia supera la
capacitC c, allora .uesta non potrC certaente salire, .uin$i JSi, cT avrC lo stesso valore $el caso in cui ci
siano solo le prie i#1 persone, cio JSi#1, cT.
%nvece, se il peso $ella persona i#esia inore o uguale $ella capacitC c, allora a""iao $ue possi"ilitC(
1. 2ar salire la persona i#esiaD in .uesto caso il nuero assio $i persone sull'ascensore JSi#1, c#
(SiTT E 1D
2. 939 0ar salire la persona i#esiaD in .uesto caso il nuero assio $i persone JSi#1, cT.
9aturalente, tra le $ue opzioni prece$enti scegliereo .uella che ci consente $i assiizzare il valore $i
JSi, cT. Quin$i possiao $e0inire JSi, cT coe(
J [i % c]=
{
ma? { J [ i1, c] % J [i1, c,[i]]+1} se c([i ]
J [i1, c] altrienti
1opo aver copilato la ta"ella $i prograazione $inaica in tepo /n<4, il risultato si leggerC nella
casella JSn, <T.
Esercizio %.1$
1isponete $i n scatole s
1
, s
2
, W, s
n
a 0ora $i parallelepipe$oD la scatola s
i
larga ?SiT, alta #SiT e pro0on$a
@SiT. ]ogliao cercare $i inserire una $entro l'altra il aggior nuero possi"ile $i scatole, senza ruotarle. ,a
scatola s
i
puN essere inserita in s
j
se e solo se valgono entra"e .ueste con$izioni(
1. i Q j K la scatola esterna $eve avere una etichetta aggiore $ella scatola interna
:> Capitolo 8( &rograazione 1inaica 63MM!
2. ?SiT Q ?SjT e #SiT Q #SjT e @SiT Q @SjT ( la scatola esterna $eve avere $iensioni strettaente aggiori
$ella scatola interna
*crivere un algorito e00iciente, "asato sulla prograazione $inaica, che $ati in input il valore $i n e i
vettori ?S1..nT, #S1..nT e @S1..nT, restituisca il assio nuero $i scatole che possono essere inserite l'una
nell'altra.
Soluzione. 1e0iniao con JSjT il assio nuero $i scatole in [s
1
, W s
j
\ che possono essere inserite l'una
nell'altra, usan$o in ogni caso la scatola s
j
coe scatola pi- esterna.
3sserviao che JS1T I 1. Cerchiao ora $i $e0inire una espressione per JSjT, s0ruttan$o l'i$ea seguente.
Coe inio avreo JSjT I 1, nel caso in cui nessuna $elle prece$enti scatole s
1
, ... s
j#1
possa essere inserita
$entro s
j
. *upponiao invece che la scatola i#esia, per un certo i Q j, possa essere inserita $entro s
j
D .uesto
puN succe$ere se ?SiT Q ?SjT, #SiT Q #SjT e @SiT Q @SjT. %nseren$o s
i
$entro s
j
otterreo JSiT E 1 scatole
correttaente inserite l'una nell'altra, in .uanto sappiao che possi"ile inserire JSiT scatole usan$o s
i
coe
scatola pi- esterna.
Quin$i( tra tutte le scatole s
i
che che possono essere inserite $entro s
j
, scegliao .uella per cui il valore
JSiT E 1 risulta assio possi"ile. Questo eccaniso ci consente $i calcolare JSjT per ogni jD poichO siao
interessati a$ inserire il assio nuero $i scatole una $entro l'altra, la soluzione sarC sepliceente il
assio valore $i JSjT per ogni j I 1, ... n
algoritmo MAQNUM);A+*2&( arra" L,1..n- .i dou#le/ arraH H,1..n- .i dou#le/ arraH z,1..n- .i
dou#le ) int
arra" N,1..n- .i int! // N.01 ? #a9 nu#/ di contenitori inscatoa&ii usando s0
int NmaL! // %aore #assi#o di N.1//n1
// Ini$iai$$a$ione
N,1- :$ 1!
NmaL :$ N,1-!
for 0 :$ 2 to n do
N,0- :$ 1!
for i:$1 to 0 " 1 do
if ( L,i- I L,0- ?? H,i- I H,0- ?? z,i- I z,0- ?? N,i-%1 1 N,0-) then
N,0- :$ N,i-%1!
endif
endfor
if ( N,0- 1 NmaL ) then
NmaL :$ N,0-!
endif
endfor
return NmaL!
Esercizio %.1%
%l Ministero per l'%struzione e l'BniversitC $ella <uritania /M%B<4 $ispone $i un "u$get $i $ euro /intero non
negativo4 che vuole usare per 0inanziare progetti $i ricerca. *ono stati presentati n progetti $i ricerca,
nuerati $a 1 a n. %l progetto i#esio richie$e un 0inanziaento $i fSiT euro /intero non negativo4. &oichO il
"u$get $ non su00iciente per 0inanziare tutti i progetti, il M%B< ha $eciso $i 0ar valutare ciascun progetto
$a un gruppo $i esperti, che ha assegnato a ciascun progetto i un punteggio (SiT K 0.
%l M%B< inten$e 0inanziare il sottoinsiee $i progetti tali che /i4 la soa $ei "u$get $ei progetti 0inanziati
sia inore o uguale a $, e /ii4 il punteggio coplessivo $el sottoinsiee $i progetti 0inanziati sia il assio
tra tutti i sottoinsiei che so$$is0ano la con$izione /i4.
1. *crivere un algorito che, $ati in input il valore $el "u$get $, le richieste $i 0inanziaento fS1..nT e i
punteggi (S1..nT, stapa l'elenco $ei progetti 0inanzia"ili in "ase ai re.uisiti $escritti sopra.
2. Calcolare il costo coputazionale $ell'algorito proposto.
Esercizio %.1&
*ia .S1..nT un vettore coposto $a n nueri reali ar"itrari /possono essere presenti valori positivi e negativi4.
&er ogni i, j con 1 L i L c L n, sia -/i, j4 la soa $ei valori $egli eleenti $el sottovettore .Si..jTD si noti che
:8
-/i, i4 I .SiT per ogni i. *crivere un algorito in gra$o $i calcolare i valori -/i, j4, per ogni i, j, in tepo
R/n
2
4. Mo$i0icare l'algorito per risolvere il pro"lea $i $eterinare il sottovettore $i soa assia in
tepo R/n
2
4D ricor$iao che tale pro"lea puN essere risolto in tepo R/n4 usan$o la prograazione
$inaica. (-uggerimentoK usare una matrice (er memori@@are i !alori -(i% j9 * (ossibile riem(ire la matrice
in maniera o((ortuna (er ottenere il costo asintotico ric)iesto"
Soluzione. *0ruttiao un approccio ispirato alla prograazione $inaica per calcolare i costi nel o$o
seguente. Meorizziao i valori -/i, j4 in una atrice .ua$rata nn. *i noti coe solo la parte triangolare
superiore $ella atrice verrC utilizzata, $ato che i valori che ci interessano sono tutti e soli .uelli per cui iLj.
<iepiao la atrice una riga alla volta. &er ogni riga, il prio valore -/i, i4 0acilente calcolato, $ato che
-/i, i4 I .SiT per $e0inizione. 9otiao che una volta calcolato -/i, j4, possiao ie$iataente calcolare
l'eleento -/i, jE14 I -/i, j4 E .SjE1T. Quin$i ogni eleento $ella atrice puN essere calcolato in tepo 3/14D
poichO ci sono R/n
2
4 eleenti, il costo coputazionale $ell'algorito sarC R/n
2
4.
algoritmo ;A2;*2A)( arra" W,1..n- di dou#le) arra" ,1..n/ 1..n- .i dou#le
arra" ),1..n/ 1..n- .i dou#le!
for i:$1 to n do
),i/ i- :$ W,i-!
for 0:$i%1 to n do
),i/ 0- :$ ),i/ 0 " 1- % W,0-
endfor
endfor
return )
&er risolvere il pro"lea $el calcolo $el sottovettore $i soa assia, possiao esten$ere l'algorito
prece$ente coe segue(
algoritmo )*++*W&++*'&)MAQ( arra" W,1..n- di dou#le )
int imaL :$ 1! // Indice pri#o ee#ento de %ettore di so##a #assi#a
int 0maL :$ 1! // Indice uti#o ee#ento de %ettore di so##a #assi#a
dou#le )maL :$ W,1-! // So##a de)i ee#enti de %ettore di so##a #assi#a
arra" ),1..n/ 1..n- .i dou#le!
for i:$1 to n do
),i/ i- :$ W,i-!
for 0:$i%1 to n do
),i/ 0- :$ ),i/ 0 " 1- % W,0-
endfor
// A))iornia#o i #assi#o per o)ni ri)a
for 0:$i to n do
if ( ),i/ 0- 1 )maL ) then
)maL :$ ),i/ 0-!
imaL :$ i!
0maL :$ 0!
endif
endfor
endfor
print )maL/ imaL/ 0maL
Esercizio %.1'
*i consi$eri una scacchiera .ua$rata rappresentata $a una atrice ;S1..n, 1..nT. *copo $el gioco spostare
una pe$ina $alla casella $i partenza in alto a sinistra $i coor$inate /1, 14 alla casella $i arrivo in "asso a
$estra $i coor$inate /n, n4. !$ ogni ossa la pe$ina puN essere spostata $i una posizione verso il "asso
oppure verso $estra /senza uscire $ai "or$i $ella scacchiera4. Quin$i, se la pe$ina si trova in /i, j4 potrC essere
spostata in /iE1, j4 oppure /i, jE14, se possi"ile. 3gni casella ;Si, jT contiene un nuero realeD an ano che
la pe$ina si uove, il giocatore accuula il punteggio segnato sulle caselle attraversate, incluse .uelle $i
partenza e $i arrivo.
:A Capitolo 8( &rograazione 1inaica 63MM!
*crivere un algorito e00iciente che, $ata in input la atrice ;S1..n, 1..nT restituisce il assio punteggio
che possi"ile ottenere spostan$o la pe$ina $alla posizione iniziale a .uella 0inale con le regole $i cui sopra.
!$ esepio, nel caso seguente(
1 3 4 #1
3 #2 #1 5
#5 : #3 1
4 5 2 #2
l'algorito $eve restituire 1> /le celle evi$enziate in$icano il percorso $a 0ar 0are alla pe$ina per ottenere il
assio punteggio che appunto 1>4.
Soluzione. &ossiao risolvere il pro"lea utilizzan$o la prograazione $inaica. 1e0iniao una atrice
,S1..n, 1..nT $i nueri reali, tale che ,Si, jT rappresenta il assio punteggio che possi"ile ottenere
spostan$o la pe$ina $alla cella /1, 14 0ino alla cella /i, j4. Bna volta calcolati tutti i valori $egli eleenti $i &,
la risposta al nostro pro"lea sarC il valore contenuto in ,Sn, nT.
*appiao che ,S1, 1T I ;S1, 1T. 3sserviao che le celle $ella pria riga $ella atrice possono essere
raggiunte esclusivaente spostan$o la pe$ina a $estra, a partire $alla posizione iniziale. Quin$i ,S1, jT I ,S1,
j#1T E ;S1, jT, per ogni jI2, W n. !nalogaente, le celle $ella pria colonna possono essere raggiunte
esclusivaente spostan$o la pe$ina in "asso, .uin$i ,Si, 1T I ,Si#1, 1T E ;Si, 1T per ogni iI2, W n.
*upponiao ora $i voler calcolare &Si, jT per un certo iJ1, jJ1. ,a cella $i coor$inate /i, j4 puN essere
raggiunta a partire $a /i#1, j4, spostan$o la pe$ina verso il "asso $i una posizioneD in tal caso avreo che il
punteggio ottenuto $opo lo spostaento ,Si#1, jT E ;Si, jT. !lternativaente, possiao raggiungere la cella
/i, j4 a partire $a /i, j#14 spostan$o la pe$ina verso $estraD in tal caso il punteggio ottenuto ,Si, j#1T E ;Si, jT.
*i 0accia ri0eriento alla 0igura seguente
Chiaraente scegliereo la ossa che ci 0arC ottenere il punteggio assio, .uin$i possiao scrivere, per
ogni iI2, ..., n e per ogni jI2, ... n(
,[i % j ]=ma?{,[i1, j ] % ,[i % j 1]}+;[i % j ]
,'algorito seguente risolve il pro"leaD in pi-, anche se non richiesto $al testo, l'algorito stapa il
percorso che consente $i ottenere il punteggio assio. &er 0are .uesto usiao una secon$a atrice
ausiliaria GS1..n, 1..nT, tale che GSi, jT I 1 se per raggiungere la cella /i, j4 ottenen$o punteggio assio
a""iao spostato a $estra $a /i, j#14, oppure GSi, jT I #1 se per raggiungere la cella /i, j4 a""iao spostato in
"asso $a /i#1, j4.
algoritmo (:*;*);A;;=:&'A( arra" M,1..n/ 1..n- .i dou#le ) dou#le
arra" >,1..n/ 1..n- .i dou#le1
arra" =,1..n/ 1..n- .i int!
int i/ 0!
// ini$iai$$a$ione
>,1/ 1- :$ M,1/ 1-!
=,1/ 1- :$ 0! // non pro%enia#o da nessuna dire$ione
>,i"1/ 0-
>,i/ 0- >,i/ 0"1-
::
for 0 :$ 2 to n do // pri#a ri)a
>, 1/ 0 - :$ >, 1/ 0 "1 - % M, 1/ 0 -!
=, 1/ 0 - :$ 1! // pro%en)o da s9
endfor
for i:$ 2 to n do // pri#a coonna
>, i/ 1 - :$ >, i " 1/ 1 - % M, i/ 1 -!
=, i/ 1 - :$ "1! // pro%en)o da!ato
endfor
// Cacoo dea sou$ione
for i:$ 2 to n do
for 0 :$ 2 to n do
if ( >, i " 1/ 0 - X >, i/ 0 7 1 - ) then
>, i/ 0 - :$ >, i " 1/ 0 - % M, i/ 0 -!
=, i/ 0 - :$ "1! // pro%en)o da!ato
else
>, i/ 0 - :$ >, i/ 0 7 1 - % M, i/ 0 -!
=, i/ 0 - :$ 1! // pro%en)o da s9
endif
endfor
endfor
// Sta#pa a se+uen$a di casee %isitate' a partire da!uti#a (non ric7iesto
da!eserci$io)< si noti c7e NON %iene sta#pata a casea ini$iae (1' 1)/
i:$ n!
0:$ n!
)hile ( i 1 1 ?? 0 1 1 ) do
print N(N/ i/ N/P/ 0/ N)P!
if ( =, i/ 0 - $$ 1 ) then
0 :$ 0 " 1!
else
i :$ i " 1!
endif
end)hile
// restituisco a sou$ione (in*atti !a)orit#o restituisce un nu#ero reae)
return >,n/ n-!
%l costo $ell'algorito $oinato $al ciclo per il calcolo $egli eleenti $ella atrice &, e$ pari a R/n
2
4.
Esercizio %.2(
S&ro"lea "asato su 10.5 $el li"ro $i testoT ,a C%9! /Copagnia %taliana per il 9oleggio $i !utoo"ili4
$ispone $i k autoo"ili, tutte $isponi"ili per n giorni. Bna stessa autoo"ile puN avere costo $i a00itto
$iverso in giorni $iversi( in$ichereo con cSa, gT il costo per il noleggio $ell_autoo"ile a nel giorno g, $ove
1 L a L k e 1 L g L n. Bn cliente si rivolge alla C%9! per procurarsi un ezzo $i locoozione per l_intero
perio$o /giorni $a 1 a n, estrei inclusi4. &er rispariare e s0ruttare i prezzi $i noleggio igliori in ogni
giornata il cliente $isposto a ca"iare acchina $a un giorno all_altro. &er ottenere un ca"io, perN,
costretto $alla C%9! a pagare una penale , , che si aggiunge al costo $i noleggio. %l costo $i una se.uenza $i
noleggio .uin$i $ato $alla soa $ei costi $i noleggio e $elle penali pagate per i ca"i. 1ati k, n, i costi
cSa, gT e l'iporto $ella penale ,(
1. Calcolare il nuero $i possi"ili se.uenze $i noleggio $iverse.
2. *crivere un algorito che calcoli la se.uenza $i noleggio $i costo inio, nell_ipotesi in cui la
penale , sia pari a zero.
3. &roporre un algorito e00iciente che calcoli la spesa inia per il cliente tra tutte le possi"ili
se.uenze $i noleggio, assuen$o una penale , J 0D
4. Mo$i0icare l_algorito proposto al punto prece$ente in o$o $a avere in output la se.uenza $i
noleggio $i costo inio.
Soluzione . %l nuero $elle possi"ili se.uenze $i noleggio k
n
. Quin$i un eventuale algorito risolutivo che
operi $i 0orza "ruta non sare""e pratica"ile.
100 Capitolo 8( &rograazione 1inaica 63MM!
9el caso in cui la penale sia zero, possi"ile in$ivi$uare 0acilente la se.uenza $i noleggio $i costo
inio( in0atti, per ogni giorno iI1, W, n "asta scegliere la vettura a tale che cSa, iT sia inio. %n altre
parole, per ogni giorno si sceglie $i noleggiare la vettura pi- conveniente in .uel giorno.
9el caso generale in cui la penale sia strettaente positiva, possiao s0ruttare la prograazione $inaica
per in$ivi$uare la se.uenza $i noleggio $i costo inio. 1e0iniao CostSi, jT il costo inio tra tutte le
se.uenze $i noleggio $urante i prii j giorni, tali che al giorno j#esio usino l_auto i, per ogni jI1, W, n e
iI1, W, k.. Consi$eran$o i noleggi solo per il prio giorno /j I 14, possiao scrivere(
<ost [ i %1]=c[ i %1]
9el caso $i se.uenze $i noleggio che $urano 0ino al giorno j J 1, l_ac.uirente ha a $isposizione le seguenti
alternative(
*e il giorno j#1 il cliente usa la stessa auto i, senza e00ettuare alcun ca"io, ottiene un costo $i noleggio pari
a
<ost [ i % j ]=<ost [ i % j 1]+c[ i % j ]
*e il giorno j#1 il cliente usa un'auto m i, ottiene un costo $i noleggio pari a
<ost [ i % j ]=<ost [ m% j1]+c[ i % j ]+,
%l costo CostSi, jT $ella se.uenza ottia $i noleggio sarC .uin$i il inio tra le alternative $escritte sopra,
ossia
<ost [ i % j ]=min
mi
{ <ost [ i % j1]+c[i % j ] % <ost [ m% j1]+c[ i % j ]+(}
%l costo inio tra tutte le se.uenze $i noleggio per tutti i n giorni, $ato $al valore inio $ell_ultia
colonna $ella atrice Cost, ossia
min
i =1, ... k
{<ost [ i % n]}
Esercizio %.21
Bn "i"liotecario $eve $isporre n li"ri su sca00ali $i larghezza =. % li"ri hanno larghezze ?S1..nT e altezze
#S1..nTD essi vanno $isposti su un nuero potenzialente illiitato $i sca00ali senza essere rior$inati, e
ovviaente senza ecce$ere lo spazio orizzontale $isponi"ile. ?uttavia, non necessario riepire
copletaente gli sca00ali, $ato che possi"ile lasciare .uanto spazio si vuole al terine $i ciascuno $i essi.
,'altezza $i ciascuno sca00ale pari alla assia altezza $ei li"ri che contieneD l'altezza coplessiva
$ell'intera sca00alatura pari alla soa $elle altezze $ei singoli sca00ali. ?utte le isure sono nueri reali
positivi. *i assua che nessun li"ro a""ia larghezza superiore a =.
*crivere un algorito che, $ati in input le $iensioni ?S1..nT e #S1..nT, nonchO la larghezza = $egli sca00ali,
restituisce la inia altezza coplessiva.
Soluzione. Questo pro"lea una variante un po' pi- coplessa $ell';sercizio >.4D in .uesto caso la
soluzione ottia puN essere in$ivi$uata applican$o la prograazione $inaica.
%niziao col $e0inire i sottopro"lei ,/04, ,/14, W ,/n4 $a risolvere( ,/i4 consiste nel $isporre i prii i li"ri
sugli sca00ali, secon$o le regole $ate, in o$o $a iniizzarne l'altezza coplessiva /in ,/04 non
$isponi"ile alcun li"ro4D si noti che nella soluzione $el pro"lea ,/i4, il li"ro i#esio occuperC sepre la
posizione pi- a $estra $ell'ultio sca00ale /supponen$o che gli sca00ali vengano riepiti $a sinistra verso
$estra4. %l pro"lea coplessivo corrispon$e col sottopro"lea ,/n4.
1e0iniao GSiT la soluzione ottia $el pro"lea ,/i4, per ogni iI0, 1, W nD in altre parole, GSiT l'altezza
inia coplessiva $egli sca00ali che sono necessari per ospitare i prii i li"ri.
%l pro"lea &/04 il pi- seplice $a risolvere, in .uanto non vi sono li"ri a $isposizione. Quin$i si avrC che
101
l'altezza $ella sca00alatura in tal caso sarC pari a zero( GS0T I 0.
]e$iao ora coe calcolare la soluzione GSiT $el pro"lea ,/i4, per ogni iJ0. 3sserviao che esistono
$iversi o$i per $isporre i li"ri sull'ultio sca00ale. ,a pi- seplice consiste nel posizionare il li"ro i#esio
$a soloD in tal caso l'altezza coplessiva sare""e pari a #SiT E GSi#1T. Bn'altra possi"ilitC consiste nel
posizionare i li"ri i e i#1 sull'ultio sca00ale, e gli altri nei prece$enti. %n tal caso l'altezza coplessiva
sare""e pari a a^[#SiT, #Si#1T\ E GSi#2T. %n generale, posizionan$o gli ultii i#kE1 li"ri /.uelli nuerati $a
k a i4 sull'ultio sca00ale, l'altezza Gult $ell'ultio sca00ale pari a
Gult =ma? #[ k] % #[+1] %... % #[i ]
la sua larghezza =ult pari a
=ult=?[ k ]+?[ k +1]+... ?[ i ]
e l'altezza coplessiva $i tutti gli sca00ali $iventa
Gult +G [ k1]=ma? { #[ k ] %... #[ i ]}+G [ k1]
/si 0accia ri0eriento alla 0igura seguente4
Quin$i, per calcolare GSiT necessario in$ivi$uare il valore $i k, tra tutti .ulli per cuui =ult L =, che
iniizza Gult E GSk#1T. Questo puN essere realizzato $all'algorito seguente
algoritmo 6:62:*+&;A':*( arra" L,1..n- .i dou#le/ arra" H,1..n- .i dou#le/ dou#le 2 )
dou#le
arra" =,0..n- .i dou#le!
=,0- :$ 0!
for i :$1 to n do
dou#le =min :$ %]!
dou#le 2Blt :$ 0! // spa$io occupato dai i&ri su!uti#o sca**ae
dou#le =Blt :$ 0! // ate$$a uti#o sca**ae
int 4 :$ i!
)hile ( 4 1 0 ?? 2Blt % L,4- 3 2 ) do
// Posi$iono i i&ro 0 su!uti#o sca**ae/
// Per pri#a cosa a))iorno o spa$io ori$$ontae occupato
2Blt :$ 2Blt % L,4-!
0"1
0
i"1
i
=Blt :$ maL^",0-/ O ",i-_
H,0"1-
2Blt :$ 9,0- % O % 9,i-
102 Capitolo 8( &rograazione 1inaica 63MM!
// Poi controo se !ate$$a deo sca**ae au#enta
if ( H,4- 1 =Blt ) then
=Blt :$ H,4-!
endif
// A +uesto punto controo se !ate$$a co#pessi%a di tutti )i sca**ai di#inuisce
if ( =Blt % =,4"1- I =min ) then
=min :$ =Blt % =,4"1-!
endif
4 :$ 4 7 1!
end)hile
=,i- :$ =min!
endfor
return =,n-!
Esercizio %.22
*upponiao $i $isporre $i n tipi $i valuta, e $i voler convertire una certa soa $i $enaro $alla
valuta 1 /esepio, euro4 alla valuta n /esepio, $ollari aericani4. *upponiao $i poter e00ettuare,
oltre al ca"io $iretto, anche una serie $i ca"i intere$i converten$o la valuta i nella valuta j al
tasso $i ca"io rSi% jT per ogni coppia i Q j /possiao solo convertire $a una valuta i a$ una valuta j
J i4( ciN signi0ica che parten$o $a una soa ? espressa nella valuta i, possiao ottenere un
iporto pari a /? rSi% jT4 in valuta j. 9on ci sono spese $i ca"io.
1e0inire un algorito, "asato sulla prograazione $inaica, che calcola il assio valore in
valuta n che possi"ile ottenere parten$o $a una unitC $i valuta 1 e$iante una opportuna se.uenza
$i ca"i. /*uggeriento( sia !SiT, il assio valore in valuta i che possi"ile ottenere $a una unitC
$i valuta 1 e00ettuan$o una opportuna se.uenza $i ca"i...4. Calcolare il costo asintotico
$ell'algorito proposto.
Soluzione. *0ruttiao il suggeriento, e $e0iniao !SiT coe il assio valore in valuta i#esia
che possi"ile ottenere $a una unitC $i valuta 1 e00ettuan$o una opportuna se.uenza $i ca"i.
9otiao innanzitutto che !S1T I 1 /in .uesto caso in0atti non stiao e00ettuan$o alcun ca"io4. &er
ogni i K 2, supponiao che l'ultio ca"io e00ettuato per ottenere la valuta i sia stato $alla valuta k,
per un .ualche k I 1, W i # 1. ,'iporto ottenuto sarC pari a !SkT rSk, iTD il pro"lea pero' che
non conosciao il valore $i k. %l pro"lea 0acilente risolvi"ile esainan$o tutti i valori $i k,
sceglien$o .uello per cui il pro$otto !SkT rSk, iT assio possi"ile. %n altre parole, lo schea $i
prograazione $inaica il seguente(
![ i ]=
{
1 se i =1
a^ {![ k ] r[ k %i ] % k=1, %i 1} altrienti
,a risposta al nostro pro"lea corrispon$e al valore !SnT.
,'algorito puo' essere scritto coe segue(
algoritmo ;AM6:*( arra" r,1..n/ 1..n- di dou#le ) dou#le
arra" J,1..n- di dou#le!
J,1- :$ 1!
for i :$ 2 to n do
dou#le JmaL ` J,1- # r,1/i-!
for 4 :$ 2 to i " 1 do
if ( J,4- # r,4/ i- 1 JmaL ) then
JmaL :$ J,4- # r,4/ i-!
endif
endfor
103
endfor
return J,n-!
%l costo coputazionale risulta /n
2
4
Capitolo ": #ra$i
Esercizio &.1
*i consi$eri un gra0o non orientato AI/., F4 in cui a ciascun no$o !. associato un peso reale >/!4 /che
puo' essere positivo o negativo4. Bn caino Q!
1
, !
2
, ... !
7
J si $ice monotono se >/!
1
4 Q >/!
2
4 Q ... Q >/!
7
4. %n
altre parole in un caino onotono i pesi $ei no$i attraversati $evono essere in or$ine strettaente
crescente.
1. 1iostrare che se Q!
1
, !
2
, ... !
7
J un caino onotono, allora aciclico
2. 1escrivere un algorito e00iciente che, $ato in input un gra0o non orientato AI/., F4 con no$i
pesati, e $ue no$i s, d., restituisce true se e solo se esiste un caino onotono che inizia $alla
sorgente s e terina nella $estinazione d. ,'algorito $eve anche stapare i no$i che copongono
tale caino /i no$i possono essere stapati nell'or$ine !
1
, !
2
, W !
7
oppure nell'or$ine inverso !
7
, !
7#
1
, W !
1
4
3. 1eterinare il costo coputazionale $ell'algorito $escritto al punto 2, otivan$o la risposta
Soluzione. *upponiao per assur$o che il caino onotono Q!
1
, !
2
, ... !
7
J contenga un ciclo, cio che
esistano interi 1 L i Q j L k tali che il caino possa essere scritto coe Q!
1
, W !
i
, W !
c
, W !
7
J, e Q!
i
, W !
c
J
sia un ciclo /ossia, !
i
I !
c
4. &oichO il caino iniziale onotono, lo sarC anche il sottocaino Q!
i
, W !
c
J.
Quin$i $eve essere(
>/!
i
4 Q >/!
iE1
4 Q W Q >/!
c
4 I >/!
i
4
$a cui si conclu$e >/!
i
4 Q >/!
i
4 il che assur$o.
&er .uanto riguar$a l'algorito che i$enti0ica se esiste un caino aciclico che parte $a s e terina in d,
possi"ile utilizzare una "anale variazione $ell'algorito $i visita in pro0on$itC coe segue.
algoritmo ;AMM:N*M*N*+*N*( grafo ($(W/ &)/ nodo A/ nodo . ) #ool
foreach J in W do
J.mar4 :$ @alAe!
endfor
return ;AMM:N*M*N*+*N*':;((/ A/ .)!
algoritmo ;AMM:N*M*N*+*N*':;( grafo ($(W/ &)/ nodo A/ nodo . ) #ool
A.mar4 :$ trBe!
if ( A $$ . ) then
print .!
return trBe!
else
foreach no.o L a.ia8ente a A do
if ( L.mar4 $$ @alAe ?? w(A) I w(L) ) then
if ( ;AMM:N*M*N*+*N*':;((/ L/ .) ) then
print A!
return trBe!
endif
10> Capitolo A( @ra0i 63MM!
endif
endfor
return @alAe!
endif
%l costo coputazionale esattaente .uello $i una norale visita in pro0on$itC, ossia 3/nEm4.
Esercizio &.2
Consi$erare il gra0o non orientato seguente, in cui gli archi in grassetto in$icano uno spanning tree(
1. ,o spanning tree puN essere ottenuto e$iante una visita in pro$ondit% $el gra0oU %n caso
a00erativo speci0icare il no$o $i inizio $ella visita, e rappresentare il gra0o e$iante liste $i
a$iacenza in o$o tale che l'or$ine in cui copaiono gli eleenti nelle liste consenta all'algorito
12* $i pro$urre esattaente lo spanning tree ostrato.
2. ,o spanning tree puN essere ottenuto e$iante una visita in ampiezza $el gra0oU %n caso a00erativo
speci0icare il no$o $i inizio $ella visita, e rappresentare il gra0o e$iante liste $i a$iacenza in o$o
tale che l'or$ine in cui copaiono gli eleenti nelle liste consenta all'algorito 62* $i pro$urre
esattaente lo spanning tree ostrato.
Esercizio &.3
Consi$erare il seguente gra0o non orientato(
1. @li archi in grassetto possono rappresentare un al"ero $i visita ottenuto e$iante una visita in
pro$ondit% $el gra0oU %n caso a00erativo speci0icare il no$o $i inizio $ella visita, e rappresentare il
gra0o e$iante liste $i a$iacenza in o$o tale che l'or$ine in cui copaiono gli eleenti nelle liste
consenta all'algorito 12* $i pro$urre esattaente l'al"ero ostrato.
2. @li archi in grassetto possono rappresentare un al"ero $i visita ottenuto e$iante una visita in
ampiezza $el gra0oU %n caso a00erativo speci0icare il no$o $i inizio $ella visita, e rappresentare il
gra0o e$iante liste $i a$iacenza in o$o tale che l'or$ine in cui copaiono gli eleenti nelle liste
consenta all'algorito 62* $i pro$urre esattaente l'al"ero ostrato.
Soluzione. ,a risposta a00erativa in entra"i i casi. &er la visita in pro0on$itC si puN a$ esepio partire
$a ! oppure 6. &er la visita in apiezza si puN partire a$ esepio $a 2.
%n entra"i i casi /al $i lC $el no$o $i partenza, che $i00erente per la visita 12* e 62*4 si puN ottenere
l'al"ero $i ostrato nel testo utilizzan$o, a$ esepio, la seguente rappresentazione con liste $i a$iacenza(
A
6
;
D
&
F
(
A
;
D
&
F (
=
: 6
108
9aturalente altre soluzioni corrette erano possi"ili.
Esercizio &.
*i consi$eri un gra0o orientato AI/., F4 con n no$i, nuerati $a 1 a n. %l gra0o rappresentato e$iante una
atrice $i a$iacenza.
1. *crivere un algorito per calcolare l'in$ice $i un no$o avente gra$o uscente assio /ossia l'in$ice
$i un no$o avente assio nuero $i archi uscenti4.
2. !nalizzare il costo coputazionale $ell'algorito proposto.
Soluzione. ,a soluzione consiste nel cercare l'in$ice $ella riga avente il aggior nuero $i valori 1. %n altre
parole(
algoritmo +'*WAN*D*( arra" M,1..n/ 1..n- .i int ) int
int imaL :$ 1! // nodo con )rado uscente #a9
int gmaL :$ 0! // %aore de )rado #a9
for i:$1 to n do
int g :$ 0! // )rado uscente de nodo corrente
for 0:$1 to n do
g :$ g % M,i/ 0-!
endfor
if ( g 1 gmaL ) then
gmaL :$ g!
imaL :$ i!
endif
endfor
return imaL!
*i noti che l'esercizio chie$eva $i restituire l'in$ice $el no$o $i gra$o assio, non il valore $el gra$o
assio. Quin$i restituire il valore $i gmaL sare""e stato s"agliato. %l costo asintotico $ell'algorito
R/n
2
4.
Esercizio &.!
Z $ato un gra0o non orientato AI/., F4, non necessariaente connesso, e un vertice s .. *crivere un
algorito che restituisca il nuero $i no$i che 0anno parte $ella coponente connessa $i cui 0a parte s
Soluzione. Z su00iciente usare un algorito $i visita /in apiezza o pro0on$itC, a scelta4 con una inia
o$i0ica. ]e$iao la soluzione che usa la visita in apiezza
algoritmo ;*N+A;;( grafo ($(W/ &)/ nodo A ) int
foreach J in W do
6
;
D
A
&
F
(
=
:
;
6 F
(
= :
D &
6
; A
A D
; F
; F
;
(
(
&
F
10A Capitolo A( @ra0i 63MM!
J.mar4 :$ @alAe!
endfor
int Aize :$ 1!
9U&U& 9!
A.mar4 :$ trBe!
9.&N9U&U&(A)!
)hile ( V 9.:)&M>+C() ) do
J :$ 9.D&9U&U&()!
foreach w a.ia8ente a J do
if ( w.mar4 $$ @alAe ) then
w.mar4 :$ trBe!
Aize :$ Aize%1!
9.&N9U&U&(w)!
endif
endfor
end)hile
return Aize!
Esercizio &.$
*i consi$eri una scacchiera ;S1..n,1..nT $i nn eleenti, con nJ1. 3gni cella $ella scacchiera puN contenere
il valore 0 oppure 1. *e ;Si, jT I 0, allora la cella /i, j4 li"era, altrienti occupata $a un ostacolo. Bn
giocatore viene posto inizialente nella casella /1, 14, che si assue essere sepre li"era. !$ ogni passo, il
giocatore puN uoversi in una $elle caselle li"ere a$iacenti. *peci0icaente, possi"ile spostarsi $alla cella
;Si, jT a$ una $elle celle li"ere tra ;Si#1, jT, ;SiE1, jT, ;Si, j#1T e ;Si, jE1T. &er seplicitC, supponiao che
;Si, jT sia $e0inita per .ualsiasi valore $i i e j, e ;Si, jT I 1 se aleno uno $egli in$ici non copreso tra 1 e
nD .uin$i a$ esepio, ;S0, 1T I ;S1, 0T I 1.
1. 1escrivere un algorito e00iciente in gra$o $i $eterinare il nuero inio $i passi necessari per
spostarsi $alla cella /1, 14 alla cella /n, n4, sepre che ciN sia possi"ile.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Questo pro"lea si puN risolvere e00icienteente applican$o l'algorito $i visita in apiezza
/62*4 $i un gra0o non orientato. 9on necessario costruire esplicitaente il gra0o $a esplorare. Ciascuna
cella $ella atrice un no$o $el gra0o $a esplorareD ;siste un arco tra ogni coppia $i no$i a$iacenti tali che
entra"i i no$i corrispon$ano a caselle li"ere /cio non occupate4.
*iilente all'algorito 62*, utilizziao una co$a per antenere l'elenco $ei no$i ancora $a esplorare. %n
.uesto caso la co$a contiene coppie $i interi, che rappresentano posizioni $i caselle nella scacchiera. %n pi-,
utilizziao la atrice accessoria ESi, jT che contiene la inia $istanza $ella cella /i, j4 $alla cella /1, 14.
%nizialente tutte le $istanze sono settate a Ein0inito. 3gni volta che una casella viene visitata per la pria
volta, la sua $istanza viene settata pari alla $istanza $ella cella $i provenienza, pi- uno. &er la proprietC $ella
visita 62* .uesta $istanza garantita essere la inia $istanza $alla sorgente $ella visita /ossia $alla cella
/1, 144.
algoritmo D:)+ANMAM:N:MA);A;;=:&'A( arra" M,1..n/ 1..n- .i int ) int
arra" D,1..n/ 1..n- .i int!
for i:$1 to n do
for 0:$1 to n do
D,i/ 0- :$ %in@! // setta tutte e distan$e a >in*
endfor
endfor
9BeBe 9!
D,1/ 1- :$ 0!
9.&N9U&U&( (1/ 1) )! // inserisci aa *ine dea coda
)hile ( V 9.:)&M>+C() ) do
(i/ 0) :$ 9..e[BeBe()! // estrai da!ini$io dea coda
if (i $$ n ?? 0 $$ n) then
return D,i/ 0-! // restituisce un)7e$$a ca##ino #ini#o
10:
else
.iAt :$ D,i/ 0-!
if ( M,i"1/ 0- $$ 0 ?? D,i"1/ 0- $$ %in@ ) then
D,i"1/ 0- :$ .iAt%1!
9.&N9U&U&( (i"1/ 0) )!
endif
if ( M,i%1/ 0- $$ 0 ?? D,i%1/ 0- $$ %in@ ) then
9,i%1/ 0- :$ .iAt%1!
9.&N9U&U&( (i%1/ 0) )!
endif
if ( M,i/ 0"1- $$ 0 ?? D,i/ 0"1- $$ %in@ ) then
D,i/ 0"1- :$ .iAt%1!
9.&N9U&U&( (i/ 0"1) )!
endif
if ( M,i/ 0%1- $$ 0 ?? D,i/ 0%1- $$ %in@ ) then
D,i/ 0%1- :$ .iAt%1!
9.&N9U&U&( (i/ 0%1) )!
endif
endif
end)hile
return %in@! // non esiste ca##ino
&er calcolare il costo $ell'algorito osserviao che la 0ase $i inizializzazione $ella atrice ES1..n, 1..nT ha
costo /n
2
4. %l calcolo $el caino viene e00ettuato sostanzialente e$iante una visita in apiezza $i un
gra0o coposto $a n
2
no$i /uno per ogni cella $ella atrice4 e 2n/n#14 archi /(erc)R+4. ,a 0ase $i visita ha
.uin$i costo 3/ n
2
E 2n/n#14 4 I 3/ n
2
4. &ertanto il costo $ell'algorito /n
2
4, essen$o pre$oinante la
0ase $i inizializzazione.
Esercizio &.%
Consi$eriao un gra0o orientato AI/., F4 i cui archi a""iano pesi non negativi. 1enotiao con >/u, !4 il
peso $ell'arco orientato /u, !4. <icor$iao che l'algorito $i 1ic7stra per il calcolo $ei caini inii $a
una singola sorgente s ] ha la seguente struttura generica(
algoritmo D:Z<)+'A(&N&':;*( grafo ($(W/ &)/ nodo A ) albero
inizializza D tale 8he DAJ $ %] per JKA/ e DAA $ 0
+ :$ albero @ormato .al Aolo Jerti8e A
)hile ( + ha meno .i n no.i ) do
troJa lUar8o (B/J) in8i.ente AB + 8on DAB % w(B/J) minimo
DAJ :$ DAB % w(B/J)!
ren.i B pa.re .i J in +
end )hile
return +!
1. *crivere una versione $ell'algorito $i 1ic7stra che non 0accia uso $i una co$a $i prioritC a $i una
seplice lista, in o$o che a$ ogni passo esaini sisteaticaente gli archi inci$enti per
in$ivi$uare .uello che iniizza la $istanza.
2. 1eterinare il costo coputazionale $ella variante $ell'algorito $i 1ic7stra $escritta al punto 1.
*peci0icare .uale struttura $ati viene usata per rappresentare il gra0o.
Soluzione. *upponiao che, per ogni vertice s, la $istanza tra la sorgente e s sia in$icata con l'attri"uto s.dD
possiao .uin$i scrivere la variante $ell'algorito $i 1ic7stra coe segue(
algoritmo D:Z<)+'A;*N2:)+&( grafo ($(W/ &)/ nodo A ) albero
foreach J in W do
J.. :$ %]
endfor
A.. :$ 0! // il no.o Aorgente ha .iAtanza zero .a Ae AteAAo
110 Capitolo A( @ra0i 63MM!
+ :$ albero @ormato .al Aolo Jerti8e A
2iAta 2!
2.:N)&'+(A)! // inAeriA8i A in 2
)hile ( V 2.:)&M>+C() ) do
Aia B il no.o .i 2 8on minimo Jalore .i B.. // costo2 O(n) ne caso pe))iore
rimBoJi B .a 2 // costo2 O(1) se L ( una ista doppia#ente concatenata
foreach (B/ J)& do
if ( J.. $$ % ) then
J.. $ B.. % w(B/J)!
ren.i B pa.re .i J in +!
2.:N)&'+(B)! // u non era nea ista' inseriscio/ Costo O(1)
elseif ( B.. % w(B/J) I J.. ) then
J.. :$ B.. % w(B/J)!
ren.i B nBoJo pa.re .i J in +!
// u era )i3 nea ista' non %a reinserito
endif
endfor
end)hile
return +!
*i noti che l'algorito D:Z<)+'A;*N2:)+& leggerente pi- seplice $a $escrivere rispetto all'algorito $i
1ic7stra ipleentato con co$e $i prioritC visto a lezione. %n0atti nel caso in cui u"dE>/u, !4 Q !"d, cio nel
caso in cui a""iao scoperto un caino pi- "reve tra s e ! che passa attraverso il no$o u, il no$o v non va
reinserito nella struttura $ati /nel nostro caso la lista4, perchO sicuraente vi giC contenuto.
%l costo $i D:Z<)+'A;*N2:)+& 3/n
2
4, essen$o n il nuero $i no$i $el gra0o /nIg.g4. 9otiao in0atti .uanto
segue(
1. %l ciclo 'hile viene eseguito al pi- n volte. Questo perchO a$ ogni iterazione viene estratto un no$o
$alla lista, e una volta estratto un no$o .uesto non viene pih reinserito /.uesto lo stesso
ragionaento che a""iao 0atto per calcolare il costo coputazionale $ell'algorito $i 1ic7stra
ipleentato traite co$a $i prioritC4D
2. ,a ricerca $el no$o u tale che u"d sia inio ha costo 3/n4. %n0atti la lista = conterrC al pi- n no$i
/in .uanto il gra0o ha n no$i4
3. %l corpo $el ciclo 0or viene eseguito 3/n4 volte, in .uanto un no$o puN essere inci$ente al pi- a n#
1I3/n4 altri no$i.
Esercizio &.&
Bn social net'or7 coe 2ace"oo7 puN essere rappresentato e$iante un gra0o non orientato AI/., F4, in cui
ogni no$o rappresenta un utente, e$ esiste un arco tra i no$i u e ! se e solo se gli utenti rappresentati $a u e !
sono GaiciHD assuiao che se u GaicoH $i !, allora anche ! GaicoH $i u /.uin$i A un gra0o non
orientato4. 9ota( il gra0o A potre""e non risultare connesso.
1. *crivere un algorito e00iciente che, $ato in input un gra0o non orientato A=/., F4 e un no$o ! .,
restituisce il nuero $i Gaici $i aiciH $i !, ossia restituisce il nuero $i no$i che si trovano a
$istanza 2 $a !. 9on consentito usare varia"ili glo"ali.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. Questo pro"lea si puN risolvere utilizzan$o una versione a$attata $ella visita in apiezza
/62*4. Z anche possi"ile realizzare una soluzione che non 0a uso esplicito $i una co$a, coe la seguente(
algoritmo ;*N+AAM:;:2( grafo ($(W/&)/ nodo J ) int
int 8 :$ 0! // nu#ero di %icini di secondo i%eo
foreach L in W do
L.mar4 :$ @alAe!
endfor
J.mar4 :$ trBe!
for each B a.ia8ente a J do // espora %icini di %
111
B.mar4 :$ trBe!
endfor
foreach B a.ia8ente a J do // riconsidera nuo%a#ente I %icini di %
foreach w a.ia8ente a B do // considera I %icini dei %icini
if ( w.mar4 $$ @alAe ) then
w.mar4 :$ trBe!
8 :$ 8%1! // a&&ia#o tro%ato un nuo%o %icino di i%eo 2
endif
endfor
endfor
return 8!
*e il gra0o rappresentato e$iante liste $i a$iacenza, il costo nel caso pessio 3/nEm4, essen$o n il
nuero $i no$i e m il nuero $i archi.
Esercizio &.'
*i consi$eri un gra0o non orientato AI/., F4, non necessariaente connesso, in cui tutti gli archi hanno lo
stesso peso positivo i J 0.
1. *crivere un algorito e00iciente che, $ato in input il gra0o AI/., F4 $i cui sopra e $ue no$i u e !,
calcola la lunghezza $el caino inio che collega u e !. *e i no$i non sono connessi, la $istanza
in0inita. 9on consentito usare varia"ili glo"ali.
2. !nalizzare il costo coputazionale $ell'algorito proposto al punto 1.
Soluzione. Z ovviaente possi"ile usare l'algorito $i 1ic7stra per il calcolo $ell'al"ero $ei caini
inii. ?uttavia, una tale soluzione 939 sare""e e00iciente( una soluzione con costo coputazionale
in0eriore consiste in0atti nell'esplorare il gra0o a partire $al vertice u utilizzan$o una visita in apiezza /62*,
6rea$th 2irst *earch4. <icor$iao che la visita 62* esplora i no$i in or$ine non $ecrescente rispetto alla
$istanza /intesa coe nuero inio $i archi4 $al no$o sorgente. 9el nostro caso, poichO tutti gli archi
hanno lo stesso peso positivo i, la inia $istanza $i ! $a u $ata $al inio nuero $i archi che separa i
$ue no$i, coe $eterinato $all'algorito 62*, oltiplicato per i.
,o pseu$oco$ice seguente realizza una versione $i 62* sepli0icata, in cui /i4 non viene antenuto
esplicitaente l'al"ero $i copertura /in .uanto non richiesto $all'esercizio4, e /ii4 si utilizza l'attri"uto !.$ist
settato a Ein0 /Gin0initoH4 per $enotare i no$i che non sono ancora stati esplorati /in o$o tale $a evitare
l'ulteriore attri"uto "ooleano !.ar74.
,o pseu$oco$ice il seguente(
algoritmo D:)+ANMAM:N:MAA2>=A( grafo ($(W/ &)/ nodo B/ nodo J dou#le i )dou#le
// ini$iai$$a o)ni nodo 8 co#e inesporato
foreach w in W do
w..iAt :$ %in@!
endfor!
9BeBe 9!
B..iAt :$ 0!
9.&N9U&U&(B)!
)hile ( V 9.:)&M>+C() ) do
nodo n :$ 9.D&9U&U&()!
if (n $$ J) then
return n..iAt # i! // a&&ia#o ra))iunto %
endfor
foreach w a.ia8ente a n do
if (w..iAt $$ %in@) then
w..iAt :$ n..iAt % 1!
9.&N9U&U&(w)!
endif
endfor
end)hile
// se sia#o arri%ati +ui' si)ni*ica c7e i nodo % non ( stato ra))iunto
112 Capitolo A( @ra0i 63MM!
return %in@!
,'algorito esegue una visita 62* $ell'intero gra0o nel caso peggiore, per cui il costo coputazionale lo
stesso $ella visita 62*, ovvia 3/n E m4 /nInuero $i no$i, mInuero $i archi, se il gra0o viene
ipleentato traite liste $i a$iacenza4.
Esercizio &.1(
*i consi$eri un gra0o orientato AI/.% F4, non necessariaente connesso.
1. *crivere un algorito e00iciente che, $ato in input il gra0o orientato AI/.% F4 e $ue vertici $istinti u,
!, restituisce GtrueH se e solo se esiste un caino orientato che parte $a u e con$uce in !.
,'algorito $eve ritornare G0alseH se tale caino non esiste.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1. speci0ican$o anche il tipo $i
rappresentazione $el gra0o che si consi$era.
Soluzione. Z possi"ile risolvere .uesto pro"lea e$iante un algorito $i visita 12* o 62* /poichO non
richiesto $i in$ivi$uare caini inii, si puN usare uno $ei $ue4.
Esercizio &.11
*i consi$eri un gra0o non orientato connesso AI/., F4 i cui archi hanno tutti lo stesso peso >J0. ]olen$o
calcolare un Miniu *panning ?ree $i A ovviaente possi"ile utilizzare uno $egli algoriti visti a
lezione. *0ruttan$o perN il 0atto che tutti gli archi hanno lo stesso peso, possi"ile 0are $i eglio usan$o un
algorito appositaente sviluppato.
1. 1escrivere un algorito e00iciente che, $ato in input il gra0o A e il peso > $i tutti i suoi archi,
$eterini un Miniu *panning ?ree $i A. /*uggeriento( in realtC il valore $el peso > non serve4
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Esercizio &.12
*i consi$eri un gra0o orientato AI/., F4 non pesato. <icor$iao che il gra0o trasposto A
?
si ottiene
inverten$o la $irezione $i tutti gli archi presenti in F.
1. *upponen$o che il gra0o A sia rappresentato e$iante atrice $i a$iacenza, scrivere un algorito
avente coplessitC ottia in gra$o $i o$i0icare la atrice in o$o $a tras0orare A nella sua
versione trasposta A
?
. ,'algorito $eve richie$ere spazio ulteriore O/14 /non .uin$i possi"ile
ricopiare la atrice $i a$iacenza4.
2. 1eterinare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. <icor$iao che la atrice $i a$iacenza ; $i un gra0o con n no$i una atrice .ua$rata $i
$iensione nn, tale che ;Si, jT I 1 se e solo se il gra0o contiene l'arco orientato /i, j4. &er calcolare il gra0o
trasposto necessario invertire tutti gli archi, ossia tras0orare ogni arco /i, j4 nell'arco /j, i4. &er 0are ciN
su00iciente sca"iare tra loro i valori ;Si, jT e ;Sj, iTD in pratica .uesto e.uivale a calcolare la atrice
trasposta ;
?
. !ttenzione al ciclo interno( la varia"ile j ha coe valore iniziale iE1( s"agliato 0ar partire j $a
1, in .uanto ogni eleento verre""e sca"iato $ue volte, ottenen$o nuovaente la atrice iniziale.
algoritmo ('AF*+'A)>*)+*( arra" M,1..n/ 1../n- .i int ) MU
for i :$ 1 to n"1 do
for 0 :$ i%1 to n do
int tmp :$ M,i/ 0-!
M,i/ 0- :$ M,0/ i-!
M,0/ i- :$ tmp!
endfor
endfor
return M! // restituisce a #atrice ; #odi*icata
%l corpo $el ciclo 0or pi- interno ha costo 3/14, e viene eseguito /n#14 E /n#24 E W E 2 E 1 I R/n
2
4 volte.
113
Quin$i il costo $ell'algorito R/n
2
4.
Esercizio &.13
1. 1ati un gra0o non orientato AI/., F4, un no$o s in . e un intero k J 0, scrivere un algorito $i
coplessitC ottia che ritorna true se e solo se la coponente connessa cui appartiene il no$o s ha
un nuero $i no$i L k /il no$o s $eve essere incluso nel conteggio, .uin$i se s un no$o isolato, la
coponente connessa cui appartiene ha un no$o4.
2. !nalizzare il costo coputazionale $ell'algorito proposto.
Soluzione. *i puN utilizzare una seplice variante $ell'algorito $i visita in apiezzaD si noti che non
necessario calcolare le $istanze $alla sorgente, in .uanto non rilevante per l'esercizio.
algoritmo ;;MAQ<( grafo ($(W/ &)/ nodo A/ int 4 ) #ool
foreach J in W do
J.mar4 $ @alAe!
endfor
9BeBe 9!
int Aize :$ 0! // di#ensione co#ponente connessa
A.mar4 :$ trBe!
9.&N9U&U&(A)!
)hile ( V 9.:)&M>+C() ) do
B :$ 9.D&9U&U&()! // ri#uo%i i pri#o nodo da H
Aize :$ Aize%1!
if ( Aize 1 4 ) then
return @alAe!
endif
foreach J a.ia8ente a B do
if ( J.mar4 $$ @alAe ) then
J.mar4 :$ trBe!
9.&N9U&U&(J)!
endif
endfor
end)hile
return trBe! // se arri%ia#o +ui si)ni*ica c7e a co#ponente connessa cui
appartiene s 7a A 0 nodi
%l costo .uello $i una norale visita in apiezza, ossia O/nEm4 nel caso peggiore /essen$o nInuero $i
no$i e mInuero $i archi4.
Esercizio &.1
Bn ipotetico social net'or7 rappresentato traite un gra0o non orientato AI/., F4. % no$i rappresentano gli
utenti, e ciascun arco /u, !4 $enota il 0atto che gli utenti u e ! sono GaiciH. *upponiao che in tale social
net'or7 tutti i essaggi inseriti $a un utente siano visi"ili $agli aici, e anche $agli Gaici $egli aiciH.
1. *crivere un algorito che, $ato in input il gra0o A e un no$o s, restituisce il nuero $i utenti che
ricevere""ero i essaggi inseriti $all'utente s /supponiao che s 0accia esso stesso parte $el
risultato, .uin$i a$ esepio se s un no$o isolato, l'algorito restituisce 14.
2. !nalizzare il costo coputazionale $ell'algorito $i cui al punto 1.
Soluzione. *i puN applicare il consueto algorito $i visita in apiezza o$i0icato in o$o tale $a 0erarsi
non appena scopre un no$o che si trova a $istanza J 2D sappiao in0atti che l'algoritoo $i visita in
apiezza esplora il gra0o Ga livelliH, visitan$o i no$i a $istanza via via crescente $alla sorgente.
algoritmo D:FFU):*N&( grafo ($(W/ &)/ nodo A ) int
foreach J in W do
J.mar4 :$ @alAe!
J..iAt :$ %in@!
114 Capitolo A( @ra0i 63MM!
endfor
9BeBe 9!
int 8oBnt :$ 0! // nu#ero persone c7e rice%ono )i update
A..iAt :$ 0!
A.mar4 :$ trBe!
9.&N9U&U&(A)!
)hile ( V 9.:)&M>+C() ) do
nodo B :$ 9.D&9U&U&()! // ri#uo%i i pri#o nodo da H
if ( B..iAt 1 2 ) then
return 8oBnt! // appena si incontra un nodo a distan$a I 2' si ter#ina
endif
8oBnt :$ 8oBnt % 1!
foreach J a.ia8ente a B do
if ( J.mar4 $$ @alAe ) then
J.mar4 :$ trBe!
J..iAt :$ B..iAt % 1!
9.&N9U&U&(J)!
endif
endfor
end)hile
return count! // +uesto ( necessario perc7J potre&&ero non esistere nodi a distan$a I 2
daa sor)ente' +uindi !a)orit#o potre&&e non e**ettuare #ai i return a!interno de cico
87ie
%l costo $ell'algorito 3/nEm4, essen$o in sostanza un algorito $i visita che al liite potre""e terinare
in anticipo rispetto a$ una visita 62*.
Esercizio &.1!
Bna reota cittC sorge su un insiee $i n isolotti, ciascuno i$enti0icato univocaente $a un intero
nell'intervallo 1, W, n. @li isolotti sono collegati $a ponti, che possono essere attraversati in entra"e le
$irezioni. Quin$i possiao rappresentare la cittC coe un gra0o non orientato AI/., F4, essen$o . l'insiee
$egli n isolotti e$ F l'insiee $ei ponti.
3gni ponte [u, !\ in gra$o $i sostenere un peso inore o uguale a PSu, !T. ,a atrice P sietrica, e i
pesi sono nueri reali positivi. *e non esiste alcun ponte che collega $irettaente u e !, poniao PSu, !T I
PS!, uT I #j
Bn caion $i peso , si trova inizialente nell'isolotto s /sorgente4 e $eve raggiungere l'isolotto d
/$estinazione4D per 0are .uesto puN servirsi solo $ei ponti che sono in gra$o $i sostenere un peso aggiore o
uguale a ,. *crivere un algorito e00iciente che, $ati in input la atrice P, il peso ,, nonchO gli interi s e d,
restituisca il nuero inio $i ponti che necessario attraversare per an$are $a s a d, aesso che ciN sia
possi"ile. *tapare la se.uenza $i isolotti attraversati nel percorso $i cui sopra.
Soluzione. Btilizziao un algorito $i visita in apiezza o$i0icato opportunaente per evitare $i
attraversare i ponti che non sosterre""ero il peso ,.
algoritmo A++'AW&')A:)*2&( arra" Y,1..n/ 1..n- .i dou#le/ dou#le >/ int A/ int . ) int
arra" mar4,1..n- .i #ool!
arra" parent,1..n- .i int!
arra" .iAt,1..n- .i int!
9BeBe 9!
for J :$ 1 to n do
mar4,J- :$ @alAe!
parent,J- :$ "1!
.iAt,J- :$ %in@!
endfor
mar4,A- :$ trBe!
.iAt,A- :$ 0!
9.&N9U&U&(A)!
115
)hile ( V 9.:)&M>+C() ) do
int B :$ 9.D&9U&U&()!
if ( B $$ . ) then
#rea*! // esci da cico se si estrae i nodo destina$ione daa coda
endif
for J:$1 to n do
if ( Y,B/J- X > ?? mar4,J- $$ @alAe ) then
mar4,J- :$ trBe!
.iAt,J- :$ .iAt,B-%1!
parent,J- :$ B!
9.&N9U&U&(J)!
endif
endfor
end)hile
if ( .iAt,.- $$ %in@ ) then
print NneAABn per8orAoP
else
int i :$ .!
)hile (i K "1) do
print i!
i :$ parent,i-!
end)hile!
endif
return .iAt,.-!
Esercizio &.1$
Bna rete stra$ale $escritta $a un gra0o orientato pesato AI/., F, >4. &er ogni arco /u, !4, la 0unzione costo
>/u, !4 in$ica la .uantitC /in litri4 $i car"urante che necessario consuare per percorrere la stra$a che
congiunge u con !. ?utti i costi sono aggiori o uguali a zero. *i consi$eri un veicolo che ha il ser"atoio in
gra$o $i contenere < litri $i car"urante, inizialente copletaente pieno. 9on sono presenti $istri"utori $i
car"urante.
*crivere un algorito che, $ati in input il gra0o pesato A, la .uantitC < $i car"urante inizialente presente
nel ser"atoio, e $ue no$i s e d, restituisce true se e solo se esiste un caino che consente al veicolo $i
raggiungere d parten$o $a s, senza rianere a secco $urante il tragitto. ;' possi"ile rappresentare il gra0o
coe eglio si ritiene /es., e$iante liste $i a$iacenza4.
Soluzione. Z su00iciente eseguire l'algorito $i 1ic7stra e calcolare il vettore ES!T $elle $istanze inie $al
no$o sorgente s a ciascun no$o ! raggiungi"ile $a s, utilizzan$o il consuo $i car"urante coe peso.
,'algorito restituisce true se e solo se ESdT risulta inore o uguale a <.
Esercizio &.1%
*crivere un algorito e00iciente che, $ato in input un gra0o non orientato AI/., F4, un no$o s . e un intero
dJ0, restituisce il nuero $i no$i che si trovano a $istanza inore o uguale a d $a s /il vertice s $eve essere
incluso nel conteggio4.
Esercizio &.1&
*i consi$eri il gra0o orientato AI/., F4, ai cui archi sono associati costi positivi coe illustrato in 0igura(
11> Capitolo A( @ra0i 63MM!
!pplicare GanualenteH l'algorito $i 1ic7stra per calcolare un al"ero $ei caini $i costo inio
parten$o $al no$o sorgente s / il no$o pi- a sinistra in 0igura4. Mostrare il risultato 0inale $ell'algorito $i
1ic7stra, inseren$o all'interno $i ogni no$o la $istanza inia $a s, e$ evi$enzian$o opportunaente /a$
esepio, cerchian$o il valore $el costo4 gli archi che 0anno parte $ell'al"ero $ei caini inii.
Soluzione.
Esercizio &.1'
,a appa $i un vi$eogioco rappresentata $a un gra0o non orientato AI/., F4( ogni no$o ! rappresenta una
GstanzaH, e ogni arco [u, !\ in$ica l'esistenza $i un passaggio $iretto $alla stanza u alla stanza ! /e
viceversa4. ,e stanze sono in tutto n, nuerate con gli interi $a 0 a n. ,'array $i interi ;S1..nT in$ica la
presenza o eno $i un ostro in ciascuna stanza. *e ;S!T I 0 la stanza ! li"eraD se ;S!T I 1, la stanza !
ospita un ostro. !ll'inizio $el gioco, il giocatore si trova nella stanza sD a$ ogni turno puN spostarsi $alla
stanza corrente in una a$iacente /purchO li"era4. *copo $el gioco $i raggiungere, se possi"ile, la stanza $i
$estinazione d nel inor nuero $i turni, attraversan$o esclusivaente stanze li"ere. ,e stanze s e d sono
sepre li"ere.
*crivere un algorito che, $ato in input il gra0o A, l'array ;S1..nT e i no$i s, d, restituisca il inio nuero
$i turni necessari per an$are $a s a d, se .uesto possi"ile. 9el caso in cui ciN non sia possi"ile, l'algorito
$eve restituire Ej. /9ota( se sId, l'algorito restituisce zero. *e s e d sono a$iacenti, l'algorito restituisce
14. 1eterinare il costo coputazionale $ell'algorito proposto.
Soluzione. Questo esercizio poteva essere risolto e$iante una seplice visita in apiezza opportunaente
o$i0icata per evitare le stanze occupate $a ostri. *0ruttiao il 0atto che i vertici sono i$enti0icati $a interi
nell'intervallo 1..n per scrivere il co$ice nel o$o seguente(
s
1G
1
4
2
3
R
5
G
E
F
12
1G
G
1 2
s
1
12
3
F
1G
R
15
1E
1R
1G
1
4
2
3
R
5
G
E
F
12
1G
G
1
2
118
algoritmo (:*;*( arra" M,1..n- .i int/ 3rafo ($(W/ &)/ 0ertice A/ 0ertice . ) int
arra" .iAt,1..n- .i int!
foreach J in W do
.iAt,J- :$ %in@!
endfor
9BeBe 9!
.iAt,A- :$ 0!
9.&N9U&U&(A)!
)hile ( V 9.:)&M>+C() ) do
B :$ 9.D&9U&U&()!
if ( B $$ . ) then
return .iAt,B-! // a&&ia#o ra))iunto a destina$ione
endif
foreach J a.ia8ente a B do
if ( .iAt,J- $$ %in@ ?? M,J- $$ 0 ) then
.iAt,J- :$ .iAt,B- % 1!
9.&N9U&U&(J)
endif
endfor
end)hile
return %in@! // se arri%ia#o +ui si)ni*ica c7e a destina$ione non ( ra))iun)i&ie
*i noti che a""iao sepli0icato l'algorito evitan$o $i antenere una apposita struttura $ati /oppure un
attri"uto "ooleano4 per in$icare .uali no$i sono stati visitati. %n0atti i no$i visitati sono tutti e soli .uelli per
cui la $istanza non Ein0.
%l costo coputazionale $ell'algorito .uello $i una norale visita 62*, ossia 3/nEm4 nel caso peggiore
/si noti che l'algorito terina ie$iataente non appena raggiunge il vertice d, .uin$i potre""e non
visitare l'intero gra0o4.
Esercizio &.2(
*i consi$eri un gra0o orientato non pesato A rappresentato e$iante una atrice $i a$iacenza ;S1..n, 1..nT,
$ove ;Si, jT I 1 se e solo se esiste l'arco orientato /i, j4. *i consi$eri un array $i k nueri interi <S1..kT tutti
copresi tra 1 e n.
1. *crivere un algorito e00iciente che, $ato in input la atrice ;, l'array <, e $ue interi s e d,
restituisce true se e solo se il vettore < rappresenta un caino /inteso coe se.uenza $i no$i
visitati4 $al no$o s al no$o d. 9on richiesto che < sia un caino inio, "asta che sia un
caino .ualun.ue che parte in s e terina in d.
2. !nalizzare il costo $ell'algorito proposto.
Soluzione.
algoritmo ;*N+'*22A;AMM:N*( arra" M,1..n/ 1..n- .i int/ arra" ;,1..4- .i int/ int A/ int . )
#ool
if ( ;,1- V$ A SS ;,4- V$ . ) then
return @alAe!
endif
for i:$1 to 4"1 do
if ( M, ;,i-/ ;,i%1- - V$ 1 ) then
return @alAe!
endif
endfor
return trBe!
%l costo coputazionale 3/k4
11A Capitolo A( @ra0i 63MM!
Esercizio &.21
*i consi$eri il seguente gra0o orientato(
*u alcuni archi sono in$icati i pesi, su altri no.
1. Copletare il gra0o in$ican$o $ei pesi a piacere sugli archi che ne sono sprovvisti, in o$o che
applican$o l'algorito $i 1ic7stra a partire $al no$o - si ottenga l'al"ero $ei caini inii
in$icato $agli archi in grassetto.
2. %n$icare all'interno $i ciascun no$o la $istanza inia $a -, calcolata $all'algorito $i 1ic7stra
applicato al gra0o con i pesi in$icati nel punto 1. %l no$o - giC stato etichettato con il valore 0
0
15
24
G
2
2F
1R
4
S
Capitolo ': Esercizi di
4rogrammazione
%n .uesto capitolo vengono $escritti, senza alcun or$ine preciso, alcuni esercizi $i prograazione con cui
viene chiesto $i progettare e ipleentare un algorito utilizzan$o un linguaggio $i prograazione /es.,
Fava, C, CEE...4.
Esercizio '.1
*i richie$e $i ipleentare una variante $ell'algorito 9U:;<)*'+/ che chiaereo 9U:;<)*'+2, coe segue.
1e0iniao un paraetro intero k K 0. ,'algorito 9U:;<)*'+2 $eve or$inare un vettore $i n nueri interi, in
senso non $ecrescente, in $ue 0asi. 9ella pria 0ase si applica l'algorito 9U:;<)*'+ norale, con la
$i00erenza che la ricorsione terina .uan$o la $iensione $el sottovettore $a or$inare $iventa inore o
uguale a k. 3vviaente, cosa 0acen$o al terine $ella pria 0ase l'array in generale potrC non risultare
or$inato. &er .uesto otivo, nella secon$a 0ase si copleta la proce$ura $i or$inaento eseguen$o
l'algorito 6U662&)*'+ sull'intero vettore.
*e kI0 oppure kI1, ovviaente 9U:;<)*'+2 esattaente uguale a 9U:;<)*'+, nel senso che al terine $ella
pria 0ase l'array risulta giC or$inato e la secon$a 0ase risulta super0lua. *e k J 1, invece, la secon$a 0ase
risulta in$ispensa"ile per la correttezza $ell'or$inaento.
*copo $i .uesta esercitazione lo stu$io sperientale $el tepo $i esecuzione $ell'algorito 9U:;<)*'+2 in
0unzione $el paraetro k. %n particolare(
%pleentare in Fava l'algorito 9U:;<)*'+2 coe $escritto sopra /siete li"eri $i $eci$ere coe
scegliere il pivot $ella 0ase $i partizionaento4D
*cegliere una $iensione n $el vettore $a or$inare che sia su00icienteente gran$e per poter
isurare i tepi $i esecuzione $i 9U:;<)*'+2 /a$ esepio nI2
1A
4D
Consi$erare $iversi valori $i k che siano potenze $i $ue, parten$o $a 1. !$ esepio kI1, 2, 4, A, 1>...
/ lasciata li"ertC $i scegliere .uanti $iversi valori $i k consi$erare, purchO siano in nuero
congruo4D
&er ciascuno $ei $iversi valori $i k, generare casualente una serie /a$ esepio 104 $i vettori $i n
eleenti, e isurare il tepo $i esecuzione $i 9U:;<)*'+2 su tali vettori. &er ciascuna serie $i prove
calcolare il tepo e$io $i esecuzione $i 9U:;<)*'+2.
&ro$urre un gra0ico in cui in ascissa ci siano i valori $i k consi$erati, e in or$inata le e$ie $ei tepi
$i esecuzione per ciascun set $i esperienti, coe $eterinate nel punto prece$ente.
/2acoltativo4 <ispon$ere alla seguente $oan$a( .uante iterazioni e00ettua /nel caso peggiore4
l'algorito 6u""le *ort nella secon$a 0ase $i 9U:;<)*'+2U Motivare "reveente la risposta.
Esercizio '.2
*copo $i .uesto progetto il calcolo sperientale $ell'altezza e$ia $i un al"ero "inario $i ricerca /non
"ilanciato4. Consi$eriao il pro"lea $i inserire n chiavi casuali all'interno $i un !6< inizialente vuoto, e
vogliao calcolare l'altezza e$ia $ell'!6< risultante in 0unzione $i n.
*i richie$e $i proce$ere coe segue. %pleentare in Fava la struttura $ati !l"ero 6inario $i <icerca, in cui
120 Capitolo :( ;sercizi $i &rograazione 63MM!
ogni no$o antiene una chiave reale /non necessario associare ulteriori in0orazioni alle chiavi4. ,a
struttura $ati $eve supportare l'operazione $i inseriento $i una nuova chiave, e $i calcolo $ell'altezza
$ell'al"ero. ,'operazione $i inseriento non $eve causare alcun ri"ilanciaento $ell'al"eroD non richiesto
$i ipleentare anche le 0unzioni $i cancellazione o ricerca $i chiavi.
*ia n il nuero $i no$i $ell'al"ero. *i scelgano opportunaente una costante k /a$ esepio, kI104 e un
insiee $i possi"ili valori per n /a$ esepio, nI10, 20, 30, ... oppure nI100, 200, 300, W4. &er ogni valore
$i n, costruire per k volte un al"ero "inario $i ricerca con n no$i, parten$o $all'al"ero vuoto e$ inseren$o n
chiavi reali generate casualente con $istri"uzione uni0ore nell'intervallo S0, 1T. *ia G
n
l'altezza e$ia $ei
k al"eri con n no$i che sono stati generati.
1. 1isegnare il gra0ico $i G
n
in 0unzione $i n, per tutti i valori $i n consi$eratiD
2. 9ella letteratura scienti0ica stata $ata una espressione analitica $i G
n
, nel caso $i al"eri "inari $i
ricerca contenenti una perutazione casuale $egli interi [1, W, n\. !$ esepio, si ve$a SA note on
t)e )eig)t of binar# searc) treesT $i ,uc 1evroye, Fournal o0 the !CM /F!CM4 ]olue 33 %ssue 3,
Fuly 1:A>, $isponi"ile acce$en$o $alla rete $i !teneo all'in$irizzo
http())$^.$oi.org)10.1145)5:25.5:30 oppure ST)e Geig)t of a Dandom $inar# -earc) TreeT $i 6ruce
<ee$, $isponi"ile all'in$irizzo http())citeseer^.ist.psu.e$u)vie'$oc)$o'nloa$U
$oiI10.1.1.152.12A:brepIrep1btypeIp$0. Con0rontare il risultato $el gra0ico ottenuto nel punto 1
con uno $ei risultati analitici presi $alla letteratura( sono copati"iliU
Esercizio '.3
*upponiao $i conoscere in anticipo le .uotazioni $i "orsa $ei prossii n giorni. %n particolare, per ogni
iI1, W, n conosciao il prezzo ASiT a cui possi"ile ac.uistare le azioni !CM; inc. il giorno i. %l prezzo $i
ven$ita .SiT al giorno i sepre in0eriore $i 0.5 rispetto al prezzo $i ac.uisto, ossia .SiT I ASiT V 0.5. !rati
$i tali in0orazioni, vogliao $eterinare i giorni i, j con 1 L i L j Ln tali che ac.uistan$o le azioni al giorno
i e riven$en$ole al giorno j, il gua$agno unitario A/i, j4 (I .SjT V ASiT sia il assio possi"ile. *i noti che
possi"ile ven$ere le azioni lo stesso giorno in cui vengono ac.uistato, oppure in un .ualsiasi giorno
successivoD non possi"ile ven$ere azioni pria $i averle ac.uistate.
%l progetto consiste nello sviluppo $i un prograa Fava $i coplessitC ottia che, $ati i prezzi $i ac.uisto
coe speci0icato a "reve, stapa a vi$eo il gua$agno unitario assioD non richiesta la stapa $ei giorni
in cui ac.uistare e ven$ere le azioni per ottenere il gua$agno $i cui sopra.
%l prograa $eve leggere i $ati $i input $a un 0ile $i testo avente la struttura seguente(
la pria riga contiene il valore $ell'intero nD
seguono n righe ciascuna $elle .uali contiene il prezzo $i ac.uisto ASiT espresso coe nuero reale.
!$ esepio, il 0ile $i input potre""e avere il contenuto seguente(
G
12.3
15.G
1F.5
11.2
1E.F
9ell'esepio $i cui sopra, ac.uistan$o le azioni al giorno 1 al prezzo $i 12.3 e riven$en$ole al giorno 4 al
prezzo $i 11.2#0.5 I 10.8 si avre""e un gua$agno /negativok4 $i #1.5. %l gua$agno assio si ottiene
ac.uistan$o il prio giorno al prezzo $i ac.uisto $i 12.3 e riven$en$o al terzo giorno al prezzo $i ven$ita $i
1:.>#0.5 I 1:.1D il gua$agno assio pertanto 1:.1#12.3 I >.A.
! titolo $i esepio, nella pagina $el corso presente un 0ile $i esepio /con l'in$icazione $el risultato che
l'algorito $eve stapare4. /-uggerimentoK si !eda lQFserci@io 5"64.
121
Esercizio '.
Bn circuito stapato puN essere rappresentato coe un gra0o non orientato AI/., F4, con . I [0, 1, W n#1\
l'insiee $egli n K 2 Gpie$iniH /pin4 e$ F l'insiee $elle m K 1 connessioni che collegano tra loro coppie $i
pin. % segnali elettrici si propagano $a un pin a tutti .uelli a$ esso collegati, sia $irettaente che
in$irettaente traite altri pin. !$ esepio, il circuito seguente ha nI10 pin e mI: connessioni(
% pin 0 e A sono tra $i loro collegati, entre 1 e : non lo sono.
*crivere un prograa Fava che legge $a un 0ile la $escrizione $el circuito e $a un secon$o 0ile una
se.uenza $i coppie $i pin. %l prograa $eve stapare a vi$eo, per ogni coppia nel secon$o 0ile, se i pin
sono connessi oppure no. ;' richiesto che il prograa costruisca l'insiee $elle coponenti connesse $el
gra0o e$iante una struttura Bnion#2in$D per ogni arco [u, !\ $el gra0o, il prograa unisce gli insiei
contenenti u e !. ?erinata .uesta 0ase, $ue pin s e d sono connessi se e solo se @in.(A) $$ @in.(.). ;' lasciata
li"ertC $i $eci$ere il tipo $i struttura Bnion#2in$ $a ipleentare /Quic7Bnion, Quic72in$, con o senza
euristiche4, tenen$o presente che l'ipleentazione corretta $i una euristica coporterC un punteggio
aggiore in se$e $i valutazione. 9on consentito 0are ricorso a ipleentazioni giC pronte $elle strutture
Bnion#2in$, neeno se presenti nella li"reria stan$ar$ $i Fava.
%l prio 0ile $i input, passato sulla riga $i coan$o, contiene la $escrizione $el gra0o. !$ esepio /nota( le
parole in corsivo non 0anno parte $el 0ile $i con0igurazione4(
10 Jumero di nodi n
R Jumero di arc)i m
1 2 origine% destina@ione arco 0
1 5
5 E
2 E
3 4
E R
R 4
4 0 origine% destina@ione arco m:0
%l secon$o 0ile contiene 8 K 1 coppie $i pin $a testare. !$ esepio(
5 Jumero 8 di co((ie da controllare
1 0 origine% destina@ione co((ia 0 da testare
G 0
3 1
R 1
R 2
R F origine% destina@ione co((ia 8:0 da testare
! 0ronte $egli input sopra, il prograa $eve pro$urre a vi$eo l'output seguente(
1 0 ;
G 0 N;
3 1 ;
R 1 ;
R 2 ;
0 1
G 5
2 3
E
4
R F
122 Capitolo :( ;sercizi $i &rograazione 63MM!
R F N;
,'output coposto $a 8 righe, ciascuna contenente gli i$enti0icatori $ei pin, nell'or$ine in cui copaiono
nel secon$o 0ile $i input, e la stringa ; se sono connessi, N; se non lo sono.
!nalizzare il costo asintotico $ella pria 0ase $i costruzione $elle strutture Bnion#2in$, e $ella secon$a 0ase
$i esecuzione $i tutte le .uery.
Esercizio '.!
1isponiao $i n K 1 0iles le cui $iensioni /in M64 sono nueri interi positivi, inori o uguali a >50.
1isponiao anche $i una scorta illiitata $i C1#<3M, aventi capacitC $i >50M6 ciascuno, su cui vogliao
copiare i 0iles in o$o $a non ecce$ere la capienza $ei supporti, e assicuran$osi che nessun 0ile venga
spezzato su pi- supporti $iversi. % 0iles possono essere eorizzati senza rispettare alcun or$ine pre0issato,
purchO la soa $elle $iensioni $ei 0ile presenti sullo stesso supporto non superi >50M6.
<ealizzare un algorito per allocare i 0iles sui C1#<3M senza spezzare nessun 0ile, e iniizzan$o il
nuero $i C1#<3M usati. &oichO non esistono algoriti e00icienti per risolvere .uesto pro"lea, si chie$e
$i ipleentare l'euristica seguente. *i riepie a turno ciascun C1#<3M, usan$o i 0iles ancora $a
eorizzare, in o$o $a assiizzare lo spazio occupato senza ecce$ere la capienza $ei supportiD per
.uesto richiesto l'uso $i un approccio "asato sulla prograazione $inaica. ,'algorito terina .uan$o
tutti i 0iles sono stati copiati sui supporti.
%l prograa accetta sulla riga $i coan$o il noe $i un 0ile $i input, avente la struttura seguente(
R numero di file (n
progetti 143 nome e dimensione del file 0
eAempio 242
@ilm1 133
@ilm2 1R1
programma E4
programma2 1RF
.o8Bmento 25
immagine 1F2 nome e dimensione del file n:0
%l prograa, eseguito sull'input prece$ente, $eve visualizzare il seguente output(
DiA8o: 1
progetti 143
@ilm1 133
@ilm2 1R1
immagine 1F2
)pazio libero: 1
DiA8o: 2
eAempio 242
programma E4
programma2 1RF
.o8Bmento 25
)pazio libero: 11F
%n .uesto caso vengono utilizzati $ue C1#<3MD per ciascuno viene visualizzato un hea$er DiA8o K seguito
$all'elenco $ei noi $ei 0iles /in un or$ine .ualsiasi4 con le relative $iensioni. %n0ine, la riga )pazio libero:
L in$ica lo spazio /in M64 ancora $isponi"ile sul $isco. Bna riga vuota separa ciascun "locco $al successivo.
,a relazione $eve contenere una $escrizione precisa $ell'algorito $i prograazione $inaica usato per
riepire i C1#<3M. %n particolare, in$icare(
coe sono $e0initi i sottopro"leiD
coe sono $e0inite le soluzioni a tali sottopro"leiD
coe si calcolano le soluzioni nei casi G"aseHD
coe si calcolano le soluzioni nel caso generale.
123
!nalizzare il costo asintotico $ell'algorito ipleentato /ci si ri0erisce all'algorito copleto, non solo a
.uello $i prograazione $inaica usato per riepire ciascun C1#<3M4..
Esercizio '.$
*i consi$eri una scacchiera rappresentata $a una atrice .ua$rata ;S0..n#1, 0..n#1T $i caratteri, con n K 2. ,a
casella $i coor$inate /i, j4 si consi$era li"era se contiene il carattere U.U, entre occupata se contiene il
carattere UaU. Bna pe$ina viene posizionata inizialente su una casella arcata con UAU /sorgente4, e $eve
raggiungere nel inor nuero $i osse la casella arcata con U.U /$estinazione4, se ciN possi"ile. !$ ogni
ossa, la pe$ina puN spostarsi $alla posizione /i, j4 a$ una $elle posizioni /iE1, j4, /i:1, j4, /i, jE14, /i, j#14,
purchO /i4 la posizione $i $estinazione sia li"era /la casella U.U si assue li"era4, e /ii4 la posizione $i
$estinazione sia all'interno la ta"ella /in altre parole, non si puN uscire $ai "or$i4.
%l prograa $eve accettare sulla riga $i coan$o il noe $i un 0ile $i input il cui contenuto a""ia la
seguente struttura(
10 dimensione della scacc)iera n
......##.. riga 0
##.s..##..
##....##..
####......
.......###
....######
..########
........d.
###...##..
.......... riga n:0
%l prograa $eve calcolare un caino che consenta $i spostare la pe$ina $alla posizione UAU alla posizione
U.U eseguen$o il inor nuero possi"ile $i osse. *e il caino esiste, il prograa $eve stapare a vi$eo
la scacchiera, evi$enzian$o con il carattere U%U le caselle che 0anno parte $i tale percorso /incluse .uelle
prece$enteente arcate UAU e U.U4. %e$iataente sotto, $eve stapare il nuero $i caselle che
copongono il percorso inio, inclu$en$o anche la casella iniziale e 0inale $el percorso /in sostanza, il
prograa $eve stapare il nuero $i si"oli U%U presenti sulla scacchiera4.
Con ri0eriento al 0ile $i paraetri prece$ente un possi"ile output .uesto /nota( in generale possono
esistere pi- percorsi inii, "asta calcolarne uno .ualsiasi4 (
......##..
##.++.##..
##..+.##..
####+.....
.++++..###
.+..######
.+########
.++++++++.
###...##..
..........
18
*e il percorso non esiste, cio nel caso in cui la $estinazione non sia raggiungi"ile $alla sorgente, il
prograa $eve stapare a vi$eo il essaggio non raggiBngibile.
1are una stia $el costo asintotico $ell'algorito ipleentato.
Esercizio '.%
,a pianta stra$ale $i una cittC rappresentata $a un gra0o orientato AI/., F4 coposto $a n K 2 no$i [0, 1,
124 Capitolo :( ;sercizi $i &rograazione 63MM!
W n#1\, che rappresentano incroci stra$ali, e m 1 archi che rappresentano stra$e che collegano coppie $i
incroci. 3gni arco etichettato con un valore reale positivo, che in$ica il tepo /in secon$i4 necessario per
percorrere la stra$a corrispon$ente. *u ciascuno $egli n incroci posizionato un sea0oro( pria $i poter
i"occare una .ualsiasi $elle stra$e che escono $all'incrocio /archi in uscita $al no$o corrispon$ente4
necessario aspettare che il sea0oro $iventi ver$e. 1isponiao $i una 0unzione .oBble atteAa(int i/ .oBble t),
che accetta in input l'i$enti0icativo $i un no$o i /intero copreso tra 0 e n#14, e l'istante $i tepo t in cui si
arriva all'incrocio. ,a 0unzione restituisce un valore reale K 0, che in$ica il tepo $i attesa pria che il
sea0oro $iventi ver$e. Quin$i, supponen$o $i arrivare al no$o i al tepo T, sarC possi"ile i"occare uno
$egli archi in uscita all'istante T E atteAa/i, T4.
%pleentare un prograa per calcolare il tepo inio necessario per an$are $al no$o 0 al no$o n#1, se
possi"ile, supponen$o $i trovarsi al no$o 0 all'istante tI0. *i presti attenzione al 0atto che, $a .uanto $etto
sopra, si puN i"occare una $elle stra$e uscenti $al no$o 0 all'istante atteAa(0/ 0).
%l prograa accetta un unico paraetro sulla riga $i coan$o, che rappresenta un 0ile contenente la
$escrizione $ella rete stra$ale. Bn esepio il seguente(
G numero di nodi n
E numero di arc)i m
0 1 132.3 origine% destina@ione e tem(o di (ercorren@a arco 0
1 2 12.R
0 3 23.R1
3 2 42.0
2 4 1R.33
3 4 352.F2
3 1 EG.F origine% destina@ione e tem(o di (ercorren@a arco m:0
*e il no$o $estinazione raggiungi"ile a partire $alla sorgente, il prograao stapa a vi$eo un nuero
reale che in$ica il tepo necessario per raggiungere la $estinazioneD il tepo $eve ovviaente inclu$ere le
soste ai sea0ori. *e il no$o $estinazione non raggiungi"ile $alla sorgente, il prograa stapa a vi$eo il
essaggio non raggiBngibile. !$ esepio, consi$eran$o una ipotetica ipleentazione $ella 0unzione
atteAa() che restituisce sepre il valore 5.0 /costante4, l'algorito applicato all'esepio prece$ente staperC
a vi$eo il valore(
FF.14
!nalizzare il costo asintotico $ell'algorito ipleentato.
&acoltativo: in caso $i $estinazione raggiungi"ile, stapare anche la se.uenza $i no$i visitati, incluso il
no$o 0 e il no$o n#1, nell'or$ine in cui vengono attraversati. 9ell'esepio prece$ente, l'output copleto
potre""e essere(
0 3 2 4
FF.14
in .uanto il caino che consente $i an$are $all'incrocio 0 all'incrocio n#1 nel inor tepo possi"ile
/assuen$o 5 secon$i $i attesa a$ ogni sea0oro4 0 l 3 l 2 l 4
Esercizio '.&
%l $ottor ;ett G1ocH 6ro'n $eve gui$are la sua 1e,orean lungo una stra$a rettilinea. ,'auto puN
percorrere I f con un litro $i car"urante, e il ser"atoio ha una capacitC $i < litri. ,ungo il tragitto si
trovano n E 1 aree $i sosta in$icate con 0, 1, W n, con n K 1. ,'area $i sosta 0 si trova all'inizio $ella stra$a,
entre l'area $i sosta n si trova alla 0ine. %n$ichiao con dSiT la $istanza in f tra le aree $i sosta i e iE1.
9elle n#2 aree $i sosta intere$ie [1, 2, W n#1\ si trovano $elle stazioni $i servizio nelle .uali il $ottor
6ro'n puN 0erarsi per 0are il pieno /ve$i 0igura4.
125
?utte le $istanze e i valori $i I e < sono nueri reali positivi. %l $ottor 6ro'n parte $all'area 0 con il
ser"atoio pieno, e si sposta lungo la stra$a in $irezione $ell'area n senza ai tornare in$ietro.
*i chie$e $i ipleentare un algorito per calcolare il nuero inio $i 0erate che sono necessarie per
0are il pieno e raggiungere l'area $i servizio n senza restare a secco per stra$a, se ciN possi"ile. %l
prograa legge i paraetri $i input $a un 0ile $i con0igurazione, il cui noe speci0icato sulla riga $i
coan$o. %l 0ile ha la struttura seguente(
13.3 km (ercorsi con un litro di carburante (I
30.0 ca(acitU del serbatoio% in litri (<
5 !alore di n
1G0 dV0W
1R3.E
G1.F
RR.42
24E.3
5F.2 dVn:0W
%l prograa $eve stapare a vi$eo l'elenco $elle aree $i sosta in cui l'auto si 0era a 0are ri0orniento,
oppure il essaggio non raggiBngibile nel caso in cui il $ottor 6ro'n non possa raggiungere la $estinazione
senza rianere a secco per stra$a. <icor$are che le aree $i sosta in cui presente una stazione $i servizio
sono .uelle nuerate coe [1, 2, W n#1\. 9ell'esepio sopra, il prograa $ovrC stapare(
3
G
9el caso in cui la $estinazione sia raggiungi"ile senza necessitC $i 0erate intere$ie, il prograa non
pro$urrC alcun output. !nalizzare il costo asintotico $ell'algorito proposto.
1 2 3 n"2 n"1
d,1- d,2- d,n"2-
0
d,0-
sta$ioni di ser%i$io
n
d,n-1-
5i#liografia
Fon 6entley, ,rogramming ,earls, secon$ e$ition, !$$ison#eesley, 2000, %*69 0#201#>58AA#0.
!lan !. 6ertossi, !. Montresor, Algoritmi e strutture di dati (seconda edi@ione, CittC*tu$i, 2010, %*69(
:8AAA251835>8
?hoas =. Coren, Charles ;. ,eiserson, <onal$ ,. <ivest, Cli00or$ *tein, Hntrodu@ione agli Algoritmi e
-trutture Eati 2/ed, Mc@ra'#=ill, 2005, %*69( :8AAA3A>>2515
Cail 1eetrescu, %rene 2inocchi, @iuseppe 2. %taliano, Algoritmi e strutture dati 2/ed, Mc@ra'#=ill, 200A,
%*69( :8A AA 3A> >4>A8
@ayle ,aa7ann Mc1o'ell, <racking t)e <oding Hnter!ie>K 030 ,rogramming 'uestions and -olutions
CareerCupD 5th <evise$ b enlarge$ e$ition /!ugust 22, 20114, %*69 :8A#0:A48A2A02
<o"ert *e$ge'ic7, Algoritmi in Xa!a 1/Fd", &earson. 2003. %*69 :8AAA81:21>:3