Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Dimosterazione correttezza
o
Tempo
Spazio (memoria)
ANALISI DI ALGORITMI
Dimensione dellinput
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 array 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
Binary search
Complessit:
Karatsuba
Selection sort
Complessit:
Merge sort
Complessit:
Analisi ammortizzata
Ci sono tre metodi per fare lanalisi ammortizzata:
Metodo dellaggregazione:
Counting sort
Basato non sui confronti, dipende dal range (k) dei numeri
Complessit: O(n+k)
Capitolo 3 Strutture
Specifica, implementazione
Tipi:
Statiche / dinamiche
Omogenee / disomogenee
Sequenze
o
Dinamica e lineare
Conta lordine
Ammette duplicati
Dati satellite
Set
Dizionari
Implementazioni
o
STRUTTURE ELEMENTARI
Lista circolare, bidirezionale, con sentinella
possibile realizzare le liste con i vettori, bisogna gestire per il problema della
dimensione dinamica, meglio gestirla come fa java nellarray list, incrementa ogni
volta del doppio e dimezza quando loccupazione pari ad un quarto.
Stack
Queue
FIFO
Capitolo 5 Alberi
Visita
o
Implementazioni
o
Alberi binary
Tree right(), Tree left()
Ricerca: implementazione
Complessit:
Complessit:
O(logn)
Successore-predecessore
Inserimento
Cancellazione
Complessit:
RB-Tree cancellazione
Funziona come negli ABR, solo che poi dobbiamo decidere se aggiustare o no, si
deve aggiustare solo quando il nodo cancellato nero:
Se il nodo cancellato rosso:
se il padre e uno dei figli del nodo erano rossi ci troviamo con due rossi di fila
Capitolo 7 Hashing
H(k) una funzione che tritura la chiave k (sempre allo stesso modo per) e
restituisce un valore dal range molto pi limitato di k. Ci possono essere
quindi delle collisioni.
Tutti i valori con lo stesso hash sono memorizzati nello stesso slot di un array
Funzioni di hash
o
Collisioni
Complessit
o
n chiavi, m slot
Problemi hashtable:
o
INSIEMI E DIZIONARI
Riepilogo complessit
O(N),
indipendente
dalla
dimensione
Elencare tutti gli elementi: O(m) dove m la dimensione della tabella hash
Capitolo 9 Grafi
Visite
o
Cammini minimi
o
Da singola sorgente
Tipi
o
Definizioni
o
n = |V|, m=|E|
Albero di copertura
Vertici aperti: vertici i cui archi uscenti non sono ancora stati percorsi
Vertici chiusi: vertici di cui archi uscenti sono stati tutti percorsi
Componenti connesse: si sa
Implementazioni
o
Liste di adiacenza
Spazio: O(n+m)
Verifica adiacenza: O(n)
Elenco di tutti gli archi: O(n+m)
Quando si scopre un nuovo nodo che prima non era marcato, questo
viene marcato e inserito nellalbero ricoprente (T)
Un grafo ciclico?
o
I DAG non hanno archi allindietro, per cui quando se ne trova uno si
restituisce false.
Ordinamento topologico: In che ordine fare le cose per eseguire tutti i task, ad
esempio con make (richiede un DAG)
o
Basata su DFS
HEAP MFSET
Code con priorit
Le operazioni base viste fin ora (cancellazione, inserimento ecc) possono non
bastare, certe volte dobbiamo inventarne di nuove. Le code di priorit sono una
struttura dati fatta apposta per essere efficiente a fare determinate operazioni. Gli
oggetti sono estratti dalla cosa in base alla loro priorit.
Heap
un particolare tipo di coda di priorit nella quale i dati sono mantenuti in modo
parzialmente ordinato.
Max heap: albero binario completo in cui la radice sempre il maggiore. (anche
nei sottoalberi, il padre sempre il maggiore)
Min heap: albero binario completo in cui la radice sempre minore (anche nei
sottoalberi)
Gli heap non impongono nessun ordinamento fra i figli di un nodo (ordinamento
parziale), limportante che i padre sia maggiore o minore rispettivamente per il
max e per il min heap.
Array heap
Serve per mantenere la propriet dei max heap dopo un inserimento Complessit:
O(logn)
Ogni sottoalbero deve essere un max heap, quindi si cerca di fare scendere fino al
posto giusto il valore
Heap build
Complessit: O(nlogn)
Riduzione priorit
MFSET
Servono a rappresentare degli insiemi disgiunti, le operazioni fondamentali sono
unire pi insiemi, identificare linsieme a cui appartiene un oggetto. una collezione
di insiemi dinamici disgiunti (un insieme di insiemi). Ogni insieme rappresentato
da un rappresentante univoco. Le ricerche del rappresentate sullo stesso insieme
devono restituire sempre lo stesso oggetto. Solo dopo un unione questo oggetto pu
cambiare. Si pu scegliere lelemento pi piccolo/grande di un insieme
Complessit:
find O(1)
merge O(n)
merge O(1)
conviene anche inserire leuristica del peso (se liste) / rango (se alberi) e la
compressione dei percorsi. Euristica sul peso: ho due liste, per unirle devo scegliere
uno dei due rappresentanti ed applicarlo allaltra lista, logicamente attacco la pi
corta alla pi lunga, quindi mi salvo anche la dimensione.
Nel caso delle liste: ogni elemento contiene un puntatore al successivo, un
puntatore al rappresentante ed un oggetto
Teorema di Bellman:
o
Per ogni arco del grafo (intero stavolta, non solo dellalbero ricoprente)
La distanza calcolata da noi deve essere minore o uguale a
quella che si otterrebbe usando larco (u, v)
O(n2)
Pesi positivi
O(m log n)
Pesi positivi
O(m + n log n)
Pesi positivi
Coda
O(mn)
DeQueue
Generalmente, superpolinomiale
DIVIDE ET IMPERA
Divide: dividi il problema in sotto problemi pi piccoli ed indipendenti
Impera: risolvi i sotto problemi ricorsivamente
Combina: unisci le soluzioni dei sottoproblemi
Parentesizzare (decidere
matrice fare prima)
Strassen
O(n2.81)
quale
Complessit:
motiplicazione
di
Winograd
O(n2,38)
Divide-et-impera
o
Ricorsiva
Top-down
Programmazione dinamica
o
Iterativa
Bottom-up
Se ci si rende conto che tutti gli N slot della cache verranno riempiti,
tanto vale calcolarli tutti, iterativamente, partendo dal caso base e
arrivando a quello che ci interessa. A questo punto si pu togliere le
chiamate ricorsive e sostituirle con un fiducioso
cache[argomentoConCuiAvreiChiamatoLaFunzioneRicorsivamente],
visto che lo avremo sicuramente gi calcolato (a questo punto si
sceglie un nuovo nome per la variabile cache)
Sottostruttura ottima
o
O(n3)
Zaino [...]
LCS viene usato nel diff per confrontare file, vedendo quali righe sono
state aggiunte e quali tolte (le modifiche vengono viste come
aggiunta+cancellazione)
Distanza di Levenshtein
Numero di add/del/edit per trasformare una stringa in un altra
TODO TODO
Capitolo 14 Greedy
Conseguenze:
Elimino tutte le attivit che non sono compatibili con la scelta ingorda
Zaino:
Sottostruttura ottima
o
Sia
un alfabeto, f un array di frequenze
x, y i due caratteri che hanno frequenza pi bassa
Allora
Esiste un codice prefisso ottimo per in cui x,y hanno la stessa profondit
massima e i loro codici differiscono solo per l'ultimo bit
Dimostrazione
Al solito, basata sulla trasformazione di una soluzione ottima
Supponiamo che esistano due caratteri a,b con profondit massima e questi
siano diversi da x,y
Scelta greedy:
Assumiamo (senza perdere in generalit): f[x] f[y] f[a] f[b]
Dimostriamo che:
La regola per riconoscere gli archi sicuri data dal seguente teorema:
Sia G=(V,E) un grafo non orientato e connesso
Sia w una funzione peso a valori reali definita su E
Sia A E contenuto in un qualche albero di copertura minimo per G
Sia (S,V-S) un qualunque taglio che rispetta A
Sia [u,v] un arco leggero che attraversa il taglio.
Allora
larco [u,v] sicuro per A
Corollario:
Sia G=(V,E) un grafo non orientato e connesso
Sia w una funzione peso a valori reali definita su E
Sia A E contenuto in un qualche albero di copertura minimo per G
Sia C una componente connessa (un albero) nella foresta GA=(V,A)
Sia [u,v] un arco leggero che connette C a qualche altra componente in GA
Allora
larco [u,v] sicuro per A
ShellSort
Inversioni di una sequenza: numero di coppie nellordine sbagliato
Problemi di flusso
f(u, v) = -f(v, u)
f(u, v) c(u, v)
Valore di flusso:
o
Sommatoria di tutti i flussi tra tutti i nodi (in pratica, quanto passa visto
che gli opposti si annullano)
Capacit residua di un flusso: funzione che ci dice per ogni coppia di nodi,
quanto avanzerebbe per quellarco
Rete residua: (V, Er, s, p, r) come loriginale, solo che la capacit sostituita
dalla capacit residua e gli archi sono tutte le coppie per cui rimane una
capacit residua
Capacit del cammino: la pi piccola tra quelle degli archi del cammino
Taglio: suddivisione in due dei nodi in modo che sorgente e pozzo rimangano
separati
Capacit del taglio: la somma, per ogni coppia di nodi tra parte 1 e parte 2,
delle capacit
Il flusso che attraversa un taglio la somma, per ogni coppia di nodi tra parte
1 e parte 2, dei flussi
f un flusso massimo
Varianti
o
Capitolo 16 Backtrack
Tipi di problem
o
IEnumerable<Solution> GetPossibleSolutions()
Solution GetFirstSolution()
int CountPossibleSolutions()
Giro di cavallo: andare ni giro col cavallo su una scacchiera fino a ricoprire
tutte le celle esattamente una volta
o
Statistica
Algoritmi statistici sui vettori: estraggono da un vettore numerico alcune
caratteristiche statistiche rilevanti (media, varianza, moda, mediano).
Selezione: dato un array di valori distinti ed un valore K compreso nel range del
vettore, trovare lelemento che maggiore di esattamente k-1 elementi.
Ricerca del minimo, massimo:
T(n) = n-1 = (n) confronti
Possiamo dimostrare che questo algoritmo ottimale? Idea:
scelta del minimo come un torneo
Tutti gli elementi (tranne il vincitore) deve perdere almeno un partita
Quindi il problema (n)
Trovare il secondo minimo dellarray
L'albero del torneo permette di trovare il secondo minimo in O(n + log n) confronti nel
caso pessimo:
n passi necessari per la ricerca del minimo
Siano M e S il minimo e il secondo minimo
Sicuramente c' stato un incontro fra M e S, dove M ha vinto
Se cos non fosse, esisterebbe un valore X<S che ha battuto S assurdo dalla
definizione di S
Quindi, basta cercare nei log n valori battuti direttamente da M per trovare il
secondo minimo. Totale: O(n + log n)
Lalbero del torneo pu essere simulato da uno heap:
Dominio limitato, quello delle tessere. Non c un algoritmo migliore della forza
bruta (si pensa che nemmeno ci sia)
Commesso viaggiatore
Certificato polinomiale
Un algoritmo che data una presunta soluzione del problema verifica in tempo
polinomiale che tale soluzione sia effettivamente una soluzione che da risposta SI.
Non determinismo
Classe P
Classe di tutti i problemi decisionali risolvibili in tempo polinomiale con algoritmi
deterministici
Classe NP
La classe di tutti i problemi decisionali risolvibili in tempo polinomiale con algoritmi
non deterministici
P contenuta in NP
Non si sa se NP contenuta in P
Riducibilit polinomiale
Siano A e B due problemi decisionali. Si dice che A si riduce in tempo polinomiale a B,
e si scrive A B, se esiste una funzione f di trasformazione:
f: (dati dingresso per A) (dati dingresso per B)
Tale che:
f computabile in tempo polinomiale con un algoritmo deterministico;
(continua)
Misc
:Onmax,
=:O(nmax, logn)
Master theorem
Tn=aTn/b+fn
a1
b1
=logba
0 :fn=On-Tn=n
fn=n
Tn=f(n)logn
0 :fn=n+
c<1 :afnbcfn Tn=f(n)
c>0, 0
a=ai
a=1On+1
a2O(nan)
ANALISI DI ALGORITMI
Dimensione dellinput
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 array 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
Binary search
Complessit:
Karatsuba
Selection sort
Complessit:
Merge sort
Complessit:
Analisi ammortizzata
Ci sono tre metodi per fare lanalisi ammortizzata:
Metodo dellaggregazione:
Counting sort
Basato non sui confronti, dipende dal range (k) dei numeri
Complessit: O(n+k)
STRUTTURE ELEMENTARI
Lista circolare, bidirezionale, con sentinella
possibile realizzare le liste con i vettori, bisogna gestire per il problema della
dimensione dinamica, meglio gestirla come fa java nellarray list, incrementa ogni
volta del doppio e dimezza quando loccupazione pari ad un quarto.
Stack
Queue
FIFO
Ricerca: implementazione
Complessit:
Complessit:
O(logn)
Successore-predecessore
Inserimento
Cancellazione
Complessit:
RB-Tree cancellazione
Funziona come negli ABR, solo che poi dobbiamo decidere se aggiustare o no, si
deve aggiustare solo quando il nodo cancellato nero:
Se il nodo cancellato rosso:
se il padre e uno dei figli del nodo erano rossi ci troviamo con due rossi di fila
INSIEMI E DIZIONARI
Riepilogo complessit
O(N),
indipendente
dalla
dimensione
Elencare tutti gli elementi: O(m) dove m la dimensione della tabella hash
HEAP MFSET
Code con priorit
Le operazioni base viste fin ora (cancellazione, inserimento ecc) possono non
bastare, certe volte dobbiamo inventarne di nuove. Le code di priorit sono una
struttura dati fatta apposta per essere efficiente a fare determinate operazioni. Gli
oggetti sono estratti dalla cosa in base alla loro priorit.
Heap
un particolare tipo di coda di priorit nella quale i dati sono mantenuti in modo
parzialmente ordinato.
Max heap: albero binario completo in cui la radice sempre il maggiore. (anche
nei sottoalberi, il padre sempre il maggiore)
Min heap: albero binario completo in cui la radice sempre minore (anche nei
sottoalberi)
Gli heap non impongono nessun ordinamento fra i figli di un nodo (ordinamento
parziale), limportante che i padre sia maggiore o minore rispettivamente per il
max e per il min heap.
Array heap
Serve per mantenere la propriet dei max heap dopo un inserimento Complessit:
O(logn)
Ogni sottoalbero deve essere un max heap, quindi si cerca di fare scendere fino al
posto giusto il valore
Heap build
Complessit: O(nlogn)
Riduzione priorit
MFSET
Servono a rappresentare degli insiemi disgiunti, le operazioni fondamentali sono
unire pi insiemi, identificare linsieme a cui appartiene un oggetto. una collezione
di insiemi dinamici disgiunti (un insieme di insiemi). Ogni insieme rappresentato
da un rappresentante univoco. Le ricerche del rappresentate sullo stesso insieme
devono restituire sempre lo stesso oggetto. Solo dopo un unione questo oggetto pu
cambiare. Si pu scegliere lelemento pi piccolo/grande di un insieme
Complessit:
find O(1)
merge O(n)
merge O(1)
conviene anche inserire leuristica del peso (se liste) / rango (se alberi) e la
compressione dei percorsi. Euristica sul peso: ho due liste, per unirle devo scegliere
uno dei due rappresentanti ed applicarlo allaltra lista, logicamente attacco la pi
corta alla pi lunga, quindi mi salvo anche la dimensione.
Nel caso delle liste: ogni elemento contiene un puntatore al successivo, un
puntatore al rappresentante ed un oggetto
DIVIDE ET IMPERA
Divide: dividi il problema in sotto problemi pi piccoli ed indipendenti
Impera: risolvi i sotto problemi ricorsivamente
Combina: unisci le soluzioni dei sottoproblemi
Parentesizzare (decidere
matrice fare prima)
Strassen
O(n2.81)
Winograd
O(n2,38)
quale
Complessit:
motiplicazione
di
TEOREMI DI ALGORITMI
----------------------------- Ricorrenze lineari con partizioni
bilanciate:
Tn= aTnb+cnn>1dn=1
Condizioni: a, b interi. a1, b2. c,d, reali. c,d>0 0
=logba
Se >
Se =
Se <
Esempio quando alfa > beta
Tn=2Tn4+1 =12,=0
Tn=On=O(n )
Esempio quando alfa = beta
Tn=2Tn4+n =12,=12
Tn=Onlogn=O(nlogn )
Esempio quando alfa < beta
Tn=2Tn4+n =12,=1
Tn=On=On
Tn=On
Tn=Onlog n
Tn=On
--------------------------------------------------------------- Master
theorem:
Tn= aTnb+f(n)n>1dn=1
=logba
Se fn=On- >0
Tn=n
Se fn=n
Tn=nlog n
Se fn=n+>0, c<1, m0 | afnbcfn nm
Tn=Of(n)
Esempio fn=On-:
Tn=9Tn3+n =log39=2 dobbiamo cercare un delta che faccia risultare -=esponente di n.
Esiste e vale 1. Quindi Tn=n2
fn=n
Tn=9Tn3+n2 =2 Quindi Tn=n2log n
fn=n+
Tn=9Tn3+n3 =2 dobbiamo cercare un delta che faccia risultare alfa + delta uguale
allesponente di n, esiste e vale 1 quindi Tn=On3
Tn= i=1haiTn-i+cnn>1dn=1
=logba
Se a=1
Se a>1
Esempio:
Tn=7Tn-2+3Tn-4+n2
a2=7 a4=3 ai=0 se i2,4. a=7+3=10. a>1Tn=O(10nn2)
Tn=On+1
Tn=O(ann)