close

Enter

Log in using OpenID

Algoritmi e strutture dati Analisi di algoritmi Introduzione

embedDownload
Introduzione
Algoritmi e strutture dati
Analisi di algoritmi
Introduzione
Alberto Montresor
Università di Trento
16 ottobre 2014
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
1 / 52
Introduzione
Introduzione
Obiettivo: stimare la complessità in tempo degli algoritmi
Definizioni
Modelli di calcolo
Esempi di valutazioni
Notazione
Perché?
Per stimare il tempo impiegato per un dato input
Per stimare il più grande input gestibile in tempi ragionevoli
Per confrontare l’efficienza di algoritmi diversi
Per ottimizzare le parti più importanti
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
2 / 52
Introduzione
Definizioni
Complessità
Definizione: Complessità: “Dimensione” → “Tempo”
Come definire la dimensione del input?
Come misurare il tempo?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
3 / 52
Introduzione
Definizioni
Dimensione dell’input
Criterio di costo logaritmico
La taglia dell’input è il numero di bit necessari per rappresentarlo
Esempio: moltiplicazione di numeri binari lunghi n bit
Criterio di costo uniforme
La taglia dell’input è il numero di elementi che lo costituiscono
Esempio: ricerca minimo in un vettore di n elementi
In molti casi...
Possiamo assumere che gli “elementi” siano rappresentati da un
numero costante di bit
Le due misure coincidono a meno di una costante moltiplicativa
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
4 / 52
Introduzione
Definizioni
Definizione di tempo
Tempo ≡ wall-clock time
Il tempo effettivamente impiegato per eseguire un algoritmo
Dipende da troppi parametri:
bravura del programmatore
linguaggio di programmazione utilizzato
codice generato dal compilatore
processore, memoria (cache, primaria, secondaria)
sistema operativo, processi attualmente in esecuzione
Dobbiamo considerare una rappresentazione più astratta
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
5 / 52
Introduzione
Definizioni
Definizione di tempo
Tempo ≡ n. operazioni elementari
Un’operazione si considera elementare se può essere eseguita in tempo
“costante” dal processore.
Esempio (Operazioni elementari)
a *= 2 ?
Math.cos(d) ?
min(A, n) ?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
6 / 52
Introduzione
Modelli di calcolo – Definizione
Modelli di calcolo
Modello di calcolo
Rappresentazione astratta di un calcolatore
Astrazione: deve permettere di nascondere i dettagli
Realismo: deve riflettere la situazione reale
Potenza matematica: deve permettere di trarre conclusioni
“formali” sul costo
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
7 / 52
P Introduzione
▶► Turing machine​ (26 P)
Modelli di calcolo – Definizione
▶► Persistence​ (2 C, 18 P)
Modelli di calcolo – Wikipedia
▶► Petri nets​ (15 P)
Pages in category "Models of computation"
The following 108 pages are in this category, out of 108 total. This list may not reflect recent changes (learn more).
E cont.
Model of computation
A
Event-driven finite-state machine
Probabilistic Turing machine
Evolution in Variable Environment
Pushdown automaton
Extended finite-state machine
Abstract Job Object
Abstract machine
P cont.
Q
F
Quantum capacity
Abstract state machines
Finite state machine with datapath
Quantum circuit
Agent-based model
Finite state transducer
Quantum computer
Algorithm characterizations
Finite-state machine
Alternating Turing machine
FRACTRAN
Applicative computing systems
Funnelsort
B
Alberto Montresor (UniTN)
H
Capitolo 2 - Analisi di algoritmi
R
Realization (systems)
Register machine
16 ottobre 2014
8 / 52
Introduzione
Modelli di calcolo – Definizione
Modelli di calcolo
Macchina di Turing
Una macchina ideale che manipola i dati contenuti su un nastro di
Macchina
di Turingsecondo un insieme prefissato di regole.
lunghezza
infinita,
Meccanismo di controllo
Testina
⊥
a1 a2 a3 a4
Nastro
Cella
Marcatore della prima cella
Ad ogni passo, la Macchina di Turing:
legge il simbolo sotto la testina
Lamodifica
macchina: il proprio stato interno
! legge il simbolo sotto la testina
nuovo
nella cella
! scrive
modifica un
il proprio
statosimbolo
(finito) interno
! scrive un nuovo simbolo nella cella
muove la testina a destra o a sinistra
! muove la testina a destra o a sinistra
Fondamentale nello
studio
della calcolabilità
Fondamentale
nello
studio
della calcolabilità
✦
Non adatto
per i nostri
Livello
troppo
bassoscopi
per i nostri scopi
✦
✦
Livello troppo basso
Alberto Montresor
(UniTN)
Capitolo 2 - Analisi di algoritmi
✦ Non sufficientemente
realistico
16 ottobre 2014
9 / 52
Introduzione
Modelli di calcolo – Definizione
Modelli di calcolo
Random Access Machine (RAM)
Memoria:
Quantità infinita di celle di dimensione finita
Accesso in tempo costante (indipendente dalla posizione)
Processore (singolo)
Set di istruzioni elementari simile a quelli reali:
somme, addizioni, moltiplicazioni, operazioni logiche, etc.
istruzioni di controllo (salti, salti condizionati)
Costo delle istruzioni elementari
Uniforme, ininfluente ai fini della valutazione (come vedremo)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
10 / 52
Introduzione
Esempi di analisi
Tempo di calcolo min()
Ogni istruzione richiede un tempo costante per essere eseguita
Costante potenzialmente diversa da istruzione a istruzione
Ogni istruzione viene eseguita un certo # di volte, dipendente da n
Item min(Item[ ] A, integer n)
Costo
#
Item min ← A[1]
for integer i ← 2 to n do
if A[i] < min then
min ← A[i]
c1
c2
c3
c4
1
n
n−1
n−1
return min
c5
1
T (n) = c1 + c2 n + c3 (n − 1) + c4 (n − 1) + c5
= (c2 + c3 + c4 )n + (c1 + c5 − c3 − c4 ) = an + b
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
11 / 52
Introduzione
Esempi di analisi
Tempo di calcolo binarySearch()
Il vettore viene suddiviso in due parti:
Parte SX: b(n − 1)/2c
Parte DX: bn/2c
integer binarySearch(Item[ ] A, Item v, integer i, integer j)
Costo
# (i > j) # (i ≤ j)
if i > j then
c1
1
1
return 0
c2
1
0
else
integer m ← b(i + j)/2c
c3
0
1
if A[m] = v then
c4
0
1
return m
c5
0
0
else if A[m] < v then
c6
0
1
return binarySearch(A, v, m + 1, j) c7 + T (bn/2c)c)
0
0/1
else
return binarySearch(A, v, i, m − 1) c7 + T (b(n − 1)/2
0
1/0
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
12 / 52
Introduzione
Esempi di analisi
Tempo di calcolo binarySearch()
Assunzioni:
Per semplicità, assumiamo n potenza di 2: n = 2k
L’elemento cercato non è presente
Ad ogni passo, scegliamo sempre la parte DX di dimensione n/2
Due casi:
i>j
(n = 0)
T (n) = c1 + c2 = c
i≤j
(n > 0)
T (n) = T (n/2) + c1 + c3 + c4 + c6 + c7
= T (n/2) + d
Relazione di ricorrenza:
(
c
se n = 0
T (n) =
T (n/2) + d se n ≥ 1
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
13 / 52
Introduzione
Esempi di analisi
Tempo di calcolo binarySearch()
Soluzione della relazione di ricorrenza tramite sostituzione
T (n) = T (n/2) + d
= T (n/4) + 2d
= T (n/8) + 3d
...
n = 2k ⇒ k = log n
= T (1) + kd
= T (0) + (k + 1)d
= kd + (c + d)
= d log n + e.
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
14 / 52
Introduzione
Notazione
Ordini di complessità
Per ora, abbiamo analizzato precisamente due algoritmi e abbiamo
ottenuto due funzioni di complessità:
Ricerca: T (n) = d log n + e
Minimo: T (n) = an + b
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
15 / 52
Introduzione
Notazione
Ordini di complessità
Per ora, abbiamo analizzato precisamente due algoritmi e abbiamo
ottenuto due funzioni di complessità:
Ricerca: T (n) = d log n + e
logaritmica
Minimo: T (n) = an + b
lineare
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
15 / 52
Introduzione
Notazione
Ordini di complessità
Per ora, abbiamo analizzato precisamente due algoritmi e abbiamo
ottenuto due funzioni di complessità:
Ricerca: T (n) = d log n + e
logaritmica
Minimo: T (n) = an + b
lineare
Una terza funzione deriva dall’algoritmo naïf per il minimo:
Minimo: T (n) = f n2 + gn + h
Alberto Montresor (UniTN)
quadratica
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
15 / 52
Introduzione
Notazione
Ordini di complessità
Per ora, abbiamo analizzato precisamente due algoritmi e abbiamo
ottenuto due funzioni di complessità:
Ricerca: T (n) = d log n + e
logaritmica
Minimo: T (n) = an + b
lineare
Una terza funzione deriva dall’algoritmo naïf per il minimo:
Minimo: T (n) = f n2 + gn + h
quadratica
Notazione O(f (n)) – Limite superiore
Un algoritmo ha complessità O(f (n)) se il suo tempo di esecuzione è
limitato superiormente da una funzione di complessità f (n).
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
15 / 52
Introduzione
Notazione
Ordini di complessità
Per ora, abbiamo analizzato precisamente due algoritmi e abbiamo
ottenuto due funzioni di complessità:
Ricerca: T (n) = d log n + e
logaritmica
O(log n)
Minimo: T (n) = an + b
lineare
O(n)
Una terza funzione deriva dall’algoritmo naïf per il minimo:
Minimo: T (n) = f n2 + gn + h
quadratica
O(n2 )
Notazione O(f (n)) – Limite superiore
Un algoritmo ha complessità O(f (n)) se il suo tempo di esecuzione è
limitato superiormente da una funzione di complessità f (n).
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
15 / 52
Introduzione
Notazione
Classi di complessità
f (n)
log n
√
n
n
n log n
n2
n3
2n
n = 101
3
3
10
30
102
103
1024
Alberto Montresor (UniTN)
n = 102
6
10
100
664
104
106
1030
n = 103
9
31
1000
9965
106
109
10300
n = 104
13
100
10000
132877
108
1012
103000
Capitolo 2 - Analisi di algoritmi
Tipo
logaritmico
sublineare
lineare
loglineare
quadratico
cubico
esponenziale
16 ottobre 2014
16 / 52
Complessità problemi vs algoritmi
Algoritmi e strutture dati
Analisi di algoritmi
Complessità algoritmi vs Complessità problemi
Alberto Montresor
Università di Trento
16 ottobre 2014
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
17 / 52
Complessità problemi vs algoritmi
Introduzione
Obiettivo: riflettere sulla complessità dei problemi e degli algoritmi
In alcuni casi, si può migliorare quanto si ritiene “normale”
In altri casi, è impossibile fare di meglio
Qual è il rapporto fra un problema computazionale e l’algoritmo?
Back to basics!
Somme
Moltiplicazioni
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
18 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri complessi
Moltiplicazione numeri complessi
(a + bi)(c + di) = [ac − bd] + [ad + bc]i
Input: a, b, c, d
Output: ac − bd, ad + bc
Domande
Considerate un modello di calcolo dove la moltiplicazione costa 1, le
addizioni/sottrazioni costano 0.01.
Quanto costa l’algoritmo dettato dalla definizione?
Potete fare di meglio?
Qual è il ruolo del modello di calcolo?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
19 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri complessi
Questioni aperte...
Si può fare di meglio?
Oppure, è possibile dimostrare che non si può fare di meglio?
Alcune riflessioni
In questo modello, effettuare 3 moltiplicazioni invece di 4 risparmia
il 25% del costo
Esistono contesti in cui effettuare 3 moltiplicazioni invece di 4 può
produrre un risparmio maggiore
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
20 / 52
Complessità problemi vs algoritmi
Sommare numeri binari
Algoritmo
elementare della somma – sum()
Sommare numeri binari
richiede di esaminare tutti gli n bit
✦ Algoritmo elementare della somma - sum()
costo
totale cn (c ≡ costo per sommare tre bit e generare riporto)
✦
Domanda
✦
richiede di esaminare tutti gli n bit
costo totale cn (c ≡ costo per sommare tre bit e generare riporto)
Esiste ✦unDomanda
metodo più efficiente?
✦
Esiste un metodo più efficiente?
11101111111111
1 0 1 1 0 0 1 1 0 1 1 0 1 1 1+
111101101101011
1101010100100010
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
21 / 52
Complessità problemi vs algoritmi
Limite inferiore alla complessità di un problema
Notazione Ω(f (n)) – Limite inferiore
Un problema ha complessità Ω(f (n)) se tutti i possibili algoritmi che lo
risolvono hanno complessità f (n) o superiore.
Limite inferiore della somma di numeri binari
Il problema della somma di numeri binari ha complessità Ω(n).
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
22 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri binari
Algoritmo elementare della somma – prod()
moltiplicazione di ogni bit con ogni altro bit
Moltiplicare numeri binari
costo totale cn2
✦
Algoritmo “elementare” del prodotto - prod()
n2
Alberto Montresor (UniTN)
*******
*******
*******
*******
*******
*******
*******
*******
*******
Capitolo 2 - Analisi di algoritmi
x
16 ottobre 2014
23 / 52
Complessità problemi vs algoritmi
Algoritmi aritmetici
Confronto della complessità computazionale
Somma : Tsum (n) = O(n)
Prodotto : Tprod (n) = O(n2 )
Si potrebbe erroneamente concludere che...
Il problema della moltiplicazione è inerentemente più costoso del
problema dell’addizione
“Conferma” la nostra esperienza
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
24 / 52
Complessità problemi vs algoritmi
Algoritmi aritmetici
Confronto fra problemi
Per provare che il problema del prodotto è più costoso del problema
della somma, dobbiamo provare che non esiste una soluzione in tempo
lineare per il prodotto
Abbiamo confrontato gli algoritmi, non i problemi!
Sappiamo solo che l’algoritmo di somma studiato alle elementari è
più efficiente dell’algoritmo del prodotto studiato alle elementari
Nel 1960, Kolmogorov enunciò in una conferenza che la
moltiplicazione ha limite inferiore Ω(n2 )
Una settimana dopo, fu provato il contrario!
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
25 / 52
Complessità problemi vs algoritmi
Moltiplicare
numeribinari
binari
Moltiplicare numeri
✦ Un metodo algoritmico: divide-et-impera
Divide-et-impera
✦
Divide:
dividi
il problema
in in
sottoproblemi
di di
dimensioni
inferiori
Divide:
dividi
il problema
sottoproblemi
dimensioni
inferiori
Impera: risolvi i sottoproblemi in maniera ricorsiva
✦
Impera: risolvi i sottoproblemi in maniera ricorsiva
Combina: unisci le soluzioni dei sottoproblemi in modo da ottenere
✦ Combina: unisci le soluzioni dei sottoproblemi in modo da ottenere
la risposta del problema principale
risposta del problema principale
Moltiplicazione
divide-et-impera
✦ Moltiplicazione ricorsiva
n/2 +
XX==aa· 2n/2
+bb
✦
✦
Y Y==cc· 2
2n/2
+dd
n/2 +
n/2
XY
= ac · 2n n+ (ad + bc) · 2n/2
+ bd
✦
XY = ac 2 + (ad+bc) 2
✦
+ bd
X
a
b
Y
c
d
Nota:
✦ Moltiplicare per 2t ≡ shift di t posizioni, in tempo lineare
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
26 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri binari tramite Divide-et-impera
boolean [ ] pdi(boolean[ ] X, boolean[ ] Y , integer n)
if n = 1 then
return X[1] · Y [1]
else
spezza X in a; b e Y in c; d
return
pdi(a, c, n/2) · 2n + (pdi(a, d, n/2) + pdi(b, c, n/2)) · 2n/2 + pdi(b, d, n/2)
T (n) =
c1
n=1
4T (n/2) + c2 · n n > 1
Nota: Moltiplicare per 2t ≡ shift di t posizioni, in tempo lineare
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
27 / 52
Complessità problemi vs algoritmi
Svolgere
la ricorsione
Analisi
della
ricorsione
0
1
2
c2 · 1 · n
nn
n/2
n/2
n/4
n/4
i
+
n/4
n/4
n/2 n/2 +
n/4
n/4
n/4
n/2
n/4
n/4
+ n/2
n/4
n/2
n/4
n/4
c2 · 4 · n/2
n/2
n/4
n/4
n/4
n/4
c2 · 42 · n/22
c2 · 4i · n/2i
Livello i: 4i istanze
n/24ii copies of n/2i
Leveldii dimensione
is the sum of
..........................
log2 n
............................................................................
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
T (1) · 4log n
= c1 · nlog 4
T (n) =
⇢
c1
4T (n/2) + c2 · n
Alberto Montresor (UniTN)
n=1
n>1
Capitolo 2 - Analisi di algoritmi
= c1 · n2
16 ottobre 2014
28 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri binari
Confronto della complessità computazionale
Prodotto : Tprod (n) = O(n2 )
Prodotto : Tpdi (n) = O(n2 )
Tutto questo lavoro per nulla?
Domanda: E’ possibile fare meglio di così?
Notate che la versione ricorsiva chiama se stessa 4 volte.
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
29 / 52
Complessità problemi vs algoritmi
Moltiplicazione di Karatsuba (1962)
A1 = ac
A3 = bd
m = (a + b)(c + d) = ac + ad + bc + bd
A2 = m − A1 − A3 = ad + bc
boolean [ ] karatsuba(boolean[ ] X, boolean[ ] Y , integer n)
if n = 1 then
return X[1] · Y [1]
else
spezza X in a; b e Y in c; d
boolean[ ] A1 ← karatsuba(a, c, n/2)
boolean[ ] A3 ← karatsuba(b, d, n/2)
boolean[ ] m ← karatsuba(a + b, c + d, n/2)
boolean[ ] A2 ← m − A1 − A3
return A1 · 2n + A2 · 2n/2 + A3
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
30 / 52
[1] · Y [1]
Complessità problemi vs algoritmi
in a; b e Y in c; d
Svolgere la ricorsione
I (a, c, n/2) · 2n + ( PDI (a, d, n/2) + PDI (b, c, n/2)) · 2n/2 + PDI (b, d, n/2)
Analisi della ricorsione
0
RATSUBA (boolean[ ]
1
[1] · Y [1]
2
n/2n/2
n/4
c2 · 1 · n
nn
X, boolean[ ] Y , integer n)
n/4
+
n/2
+
n/2
n/2
n/4
n/4
n/4
+
n/2
n/4
c2 · 3 · n/2
n/2
n/4
n/4
c2 · 32 · n/22
n/4
in a; b e Y in c; d
A1
KARATSUBA (a, c, n/2)
A3 i KARATSUBA(b,
d, n/2)
Livello
i: 3i istanze
n/24ii copies of n/2i
Leveldii dimensione
is the sum of
m
KARATSUBA (a + b, c + d, n/2)
A2
m A1 A3
1 · 2n + A2 · 2n/2 + A3
c2 · 3i · n/2i
..........................
log2 n
............................................................................
⇢
1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
T (n) =
T (n) =
⇢
c1
4T (n/2) + c2 · n
n=1
n>1
c1
3T (n/2) + c2 · n
n=1
n>1
Alberto Montresor
⇢ (UniTN)
Capitolo 2 - Analisi di algoritmi
T (1) · 3log n
= c1 · nlog 3
= n1.58...
16 ottobre 2014
31 / 52
Complessità problemi vs algoritmi
Moltiplicare numeri binari
Confronto della complessità computazionale
Prodotto : Tprod (n) = O(n2 )
Es. Tprod (106 ) = 1012
Prodotto : Tkara (n) = O(n1.58... )
Es. Tkara (106 ) = 3 · 109
Conclusioni
L’algoritmo “naif” non è sempre il migliore ...
... può esistere spazio di miglioramento ...
... a meno che non sia possibile dimostrare il contrario!
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
32 / 52
Complessità problemi vs algoritmi
Non finisce qui . . .
Toom-Cook (1963)
Noto come algoritmo Toom3, ha complessità
O(nlog 5/ log 3 ) ≈ O(n1.465 )
Karatsuba = Toom2
Moltiplicazione normale = Toom1
Schönhage–Strassen (1971)
Complessità O(n · log n · log log n)
Basato su Fast Fourier Transforms
Martin Fürer (2007)
Complessità O(n · log n · 2O(log
∗
n)
)
Limite inferiore: Ω(n log n) (congettura)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
33 / 52
Complessità problemi vs algoritmi
GNU Multiple Precision Arithmetic Library
GMP
Utilizzata da Mathematica, Maple, etc.
MUL_FFT_THRESHOLD
«Arithmetic without limitations»
Utilizza Schönhage–Strassen quando l’input è più lungo di k parole
di 64 bit, con k dipendente dall’architettura
host type
abi
z10-ibm-linux-gnu
64
atom-unknown-linux-gnu
64
z10esa-ibm-linux-gnu
32
power7-unknown-linux-gnu
mode32
bulldozer-unknown-freebsd8.3
64
piledriver-unknown-netbsd6.1.3
64
powerpc7447-unknown-linux-gnu
32
coreihwl-unknown-netbsd6.1.2
64
coreinhm-unknown-netbsd6.1.3
64
power7-ibm-aix7.1.0.0
mode64
atom-unknown-linux-gnu
32
core2-unknown-netbsd6.1.4
64
coreisbr-apple-darwin12.5.0
64
coreiwsm-unknown-linux-gnu
64
power7-unknown-linux-gnu
mode64
powerpc970-apple-darwin8.11.0
mode32
power7-ibm-aix7.1.0.0
32
bobcat-unknown-netbsd6.1.3
64
alphaev6-unknown-linux-gnu
standard
armcortexa15neon-unknown-linux- standard
power7-unknown-linux-gnu
32
Alberto
Montresor (UniTN)32
core2-unknown-netbsdelf6.1.4
host name
lgentoo4.s390.gentoo.wh0rd.org-stat
gege.gmplib.org-stat
lgentoo3.s390.gentoo.wh0rd.org-stat
gcc1-power7.osuosl.org-stat
oshell.gmplib.org-stat
pilenbsd64v61.gmplib.org-stat
spigg.gmplib.org-stat
hannahnbsd64v61.gmplib.org-stat
bikonbsd64v61.gmplib.org-stat
power-aix.fsffrance.org-stat
gege.gmplib.org-stat
repentiumnbsd64v61.gmplib.org-stat
poire.loria.fr-stat
gcc20.fsffrance.org-stat
gcc1-power7.osuosl.org-stat
g5.gmplib.org-stat
power-aix.fsffrance.org-stat
bobcat.gmplib.org-stat
agnesi.math.su.se-stat
parma.gmplib.org-stat
gcc1-power7.osuosl.org-stat
Capitolo 2 - Analisi di
repentiumnbsd32v61.gmplib.org-stat
meas
thres
1728
2240
2240
2688
3520
3712
3712
4224
4224
4288
4544
4736
4736
4736
4736
4736
5312
5504
5760
5760
5760
algoritmi
6784
conf
thres
1728
2240
2240
2688
3712
3712
3712
4224
4032
4288
4544
4736
4736
4032
4288
2688
5312
5504
5760
5760
5312
6784
cfg file
s390_64/z10/gmp-mparam.h
x86_64/atom/gmp-mparam.h
s390_32/esame/gmp-mparam.h
powerpc64/mode32/p4/gmp-mparam.h
x86_64/bd1/gmp-mparam.h
x86_64/bd2/gmp-mparam.h
powerpc32/gmp-mparam.h
x86_64/coreihwl/gmp-mparam.h
x86_64/coreinhm/gmp-mparam.h
powerpc64/mode64/p7/gmp-mparam.h
x86/atom/gmp-mparam.h
x86_64/core2/gmp-mparam.h
x86_64/coreisbr/gmp-mparam.h
x86_64/coreinhm/gmp-mparam.h
powerpc64/mode64/p7/gmp-mparam.h
powerpc64/mode32/p4/gmp-mparam.h
powerpc32/p7/gmp-mparam.h
x86_64/bobcat/gmp-mparam.h
alpha/ev6/gmp-mparam.h
arm/v7a/cora15/gmp-mparam.h
powerpc32/p7/gmp-mparam.h
16 ottobre 2014
34 / 52
x86/core2/gmp-mparam.h
Algoritmi di ordinamento
Algoritmi e strutture dati
Analisi di algoritmi
Algoritmi di ordinamento
Alberto Montresor
Università di Trento
16 ottobre 2014
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
35 / 52
Algoritmi di ordinamento
Introduzione
Obiettivo: valutare gli algoritmi in base alla tipologia dell’input
In alcuni casi, gli algoritmi si comportano diversamente a seconda
delle caratteristiche dell’input
Conoscere in anticipo tali caratteristiche permette di scegliere il
miglior algoritmo in quella situazione
Il problema dell’ordinamento è una buona palestra dove mostrare
questi concetti
Algoritmi d’ordinamento
Selection Sort
Insertion Sort
Merge Sort
Counting Sort
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
36 / 52
Algoritmi di ordinamento
Tipologia di analisi
Analisi del caso pessimo
La più importante
Il tempo di esecuzione nel caso peggiore è un limite superiore al
tempo di esecuzione per qualsiasi input
Per alcuni algoritmi, il caso peggiore si verifica molto spesso
Es.: ricerca di dati non presenti in un database
Analisi del caso medio
Difficile in alcuni casi: cosa si intende per “medio”?
Distribuzione uniforme
Analisi del caso ottimo
Può avere senso se si conoscono informazioni particolari sull’input
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
37 / 52
Algoritmi di ordinamento
Problema
Ordinamento
Problema dell’ordinamento
Input: Una sequenza A = a1 , a2 , . . . , an di n numeri
Output: Una sequenza B = b1 , b2 , . . . , bn che sia una
permutazione di A e tale per cui b1 ≤ b2 ≤ . . . ≤ bn
Approccio “demente”:
Genero tutte le possibili permutazioni fino a quando non ne trovo
una già ordinata
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
38 / 52
Algoritmi di ordinamento
Problema
Ordinamento
Problema dell’ordinamento
Input: Una sequenza A = a1 , a2 , . . . , an di n numeri
Output: Una sequenza B = b1 , b2 , . . . , bn che sia una
permutazione di A e tale per cui b1 ≤ b2 ≤ . . . ≤ bn
Approccio “demente”:
Genero tutte le possibili permutazioni fino a quando non ne trovo
una già ordinata
Approccio “naif”:
Cerco il minimo e lo metto in posizione corretta, riducendo il
problema agli n − 1 restanti valori.
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
38 / 52
Algoritmi di ordinamento
Selection Sort
Selection Sort
selectionSort(Item[ ] A, integer n)
for i ← 1 to n − 1 do
integer min ← min(A, i, n)
A[i] ↔ A[min]
integer min(Item[ ] A, integer i, integer n)
integer min ← i
% Posizione del minimo parziale
for j ← i + 1 to n do
if A[j] < A[min] then min ← j
% Nuovo minimo parziale
return min
Complessità nel caso medio, pessimo, ottimo?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
39 / 52
Algoritmi di ordinamento
Selection Sort
Selection Sort
selectionSort(Item[ ] A, integer n)
for i ← 1 to n − 1 do
integer min ← min(A, i, n)
A[i] ↔ A[min]
integer min(Item[ ] A, integer i, integer n)
integer min ← i
% Posizione del minimo parziale
for j ← i + 1 to n do
if A[j] < A[min] then min ← j
% Nuovo minimo parziale
return min
Complessità nel caso medio, pessimo, ottimo?
n−1
X
i=1
(n − i) =
i
X
=
i=1
Alberto Montresor (UniTN)
n(n − 1)
= n2 − n/2 = O(n2 )
2
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
39 / 52
Algoritmi di ordinamento
001_207_13_DEAGO_Algoritmi_OK
Insertion
Sort
Insertion Sort
28/01/14 12:25 Pagina 29
Algoritmo efficiente per ordinare piccoli insiemi di elementi
Si basa sul principio di ordinamento di una “mano“ di carte da
gioco (e.g. scala quaranta)
insertionSort(Item[ ] A, integer n)
Anal
1 2 3 4 5 6 7
for i ← 2 to n do
Item temp ← A[i]
integer j ← i
while j > 1 and A[j − 1] > temp do
A[j] ← A[j − 1]
j ←j−1
A[j] ← temp
7 4 2 1 8 3 5
4 7 2 1 8 3 5
2 4 7 1 8 3 5
1 2 4 7 8 3 5
1 2 4 7 8 3 5
1 2 3 4 7 8 5
1 2 3 4 5 7 8
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
40 / 52
Algoritmi di ordinamento
Insertion Sort
Complessità
In questo algoritmo
Il costo di esecuzione non dipende solo dalla dimensione...
ma anche dalla distribuzione dei dati in ingresso
Domande
Qual è il costo nel caso il vettore sia già ordinato?
Qual è il costo nel caso il vettore sia ordinato in ordine inverso?
Cosa succede “in media”? (informalmente)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
41 / 52
Algoritmi di ordinamento
Merge Sort
Merge Sort
Divide et impera
Merge Sort è basato sulla tecnica divide-et-impera vista in precedenza
Divide: Spezza virtualmente il vettore di n elementi in due
sottovettori di n/2 elementi
Combina: Chiama Merge Sort ricorsivamente sui due sottovettori
Impera: Unisci (merge) le due sequenze ordinate
Idea
Bisogna sfruttare il fatto che i due sottovettori sono già ordinati
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
42 / 52
Algoritmi di ordinamento
Merge Sort
Merge
primo
1
Merge(integer[ ]
mezzo
ultimo
n
A, integer primo, integer ultimo, integer mezzo)
Input:
A è un vettore di n interi
primo, ultimo, mezzo sono tali che 1 ≤ primo ≤ mezzo < ultimo ≤ n
I sottovettori A[primo . . . mezzo ] e A[mezzo +1 . . . ultimo ] sono
già ordinati
Output:
I due sottovettori sono fusi in un unico sottovettore ordinato
A[primo . . . ultimo ] tramite un vettore di appoggio B
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
43 / 52
Algoritmi di ordinamento
Merge Sort
Funzionamento Merge()
Merge Sort
i
j
A 1 3 7 8 2
i
j
A
3 7 8 2
i
A
3 7 8
i
A
7 8
i
A
7 8
i
A
7 8
Alberto Montresor (UniTN)
k
4 6 9
B
k
B 1
4 6 9
j
B 1
4 6 9
j
B 1
4 6 9
j
B 1
6 9
j
B 1
9
Capitolo 2 - Analisi di algoritmi
k
2
k
2 3
k
2 3 4
k
2 3 16 4ottobre
6 2014
44 / 52
i
j
Algoritmi di ordinamento
A
7 8
4 6 9
Funzionamento
Merge()
i
j
A
7 8
6 9
j
i
A
7 8
9
j
i
A
8
9
i
j
A
9
A
1 2 3 4 6 7 8 9
k
Merge Sort
B
1 2 3
k
B
1 2 3 4
k
B
1 2 3 4 6
k
B
B
B
1 2 3 4 6 7
k
1 2 3 4 6 7 8
k
1 2 3 4 6 7 8
© Alberto Montresor
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
45 / 52
Algoritmi di ordinamento
Merge Sort
Merge()
Merge(Item A[ ], integer primo, integer ultimo, integer mezzo)
integer i, j, k, h
i ← primo; j ← mezzo + 1; k ← primo
while i ≤ mezzo and j ≤ ultimo do
if A[i] ≤ A[j] then
B[k] ← A[i]
i←i+1
else
B[k] ← A[j]
j ←j+1
k ←k+1
j ← ultimo
for h ← mezzo downto i do
A[j] ← A[h]
j ←j−1
for j ← primo to k − 1 do A[j] ← B[j]
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
46 / 52
Algoritmi di ordinamento
Merge Sort
Costo computazionale
Domanda
Qual è il costo computazionale di Merge()?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
47 / 52
Algoritmi di ordinamento
Merge Sort
Costo computazionale
Domanda
Qual è il costo computazionale di Merge()? ⇒ O(n)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
47 / 52
Algoritmi di ordinamento
Merge Sort
Merge Sort
Programma completo:
Chiama ricorsivamente se stesso e usa Merge() per unire i risultati
Caso base: sequenze di lunghezza ≤ 1 sono già ordinate
MergeSort(Item A[ ], integer primo, integer ultimo)
if primo < ultimo then
integer mezzo ← b(primo + ultimo)/2c
MergeSort(A, primo, mezzo)
MergeSort(A, mezzo + 1, ultimo)
Merge(A, primo, ultimo, mezzo)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
48 / 52
Algoritmi di ordinamento
Merge Sort
Merge(): Partizionamento
33, 21, 7, 48, 28, 13, 65, 17
33, 21, 7, 48
33, 21
33
28, 13, 65, 17
7, 48
21
Alberto Montresor (UniTN)
7
28, 13
48
28
Capitolo 2 - Analisi di algoritmi
65, 17
13
65
16 ottobre 2014
17
49 / 52
Algoritmi di ordinamento
Merge Sort
Merge(): ricorsione
7, 13, 17, 21, 28, 33, 48, 65
7, 21, 33, 48
21, 33
33
21
Alberto Montresor (UniTN)
13, 17, 28, 65
7, 48
7
13, 28
48
28
Capitolo 2 - Analisi di algoritmi
17, 65
13
65
16 ottobre 2014
17
50 / 52
Algoritmi di ordinamento
Merge Sort
Analisi di MergeSort()
Un’assunzione semplificativa:
n = 2k , ovvero l’altezza dell’albero di suddivisioni è esattamente
k = log n;
Tutti i sottovettori hanno dimensioni che sono potenze esatte di 2
Costo computazionale: O(n log n)
(
c
n=1
T (n) =
2T (n/2) + dn n > 1
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
51 / 52
Algoritmi di ordinamento
Merge Sort
Costo computazionale di Merge Sort
Domanda
Qual è il costo computazionale di MergeSort()?
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
52 / 52
Algoritmi di ordinamento
Merge Sort
Costo computazionale di Merge Sort
Domanda
Qual è il costo computazionale di MergeSort()? ⇒ O(n log n)
Alberto Montresor (UniTN)
Capitolo 2 - Analisi di algoritmi
16 ottobre 2014
52 / 52
Author
Document
Category
Uncategorized
Views
0
File Size
1 880 KB
Tags
1/--pages
Report inappropriate content