UniTO/anno2/YearI/SecondSem/AC/algoritmi.md

Algoritmi

Elenco dei principali algoritmi studiati a lezione, usando tecniche di programmazione dinamica, branch and bound, algoritmi approssimati e algoritmi probabilistici.

Note sulla Programmazione dinamica

La programmazione dinamica e' applicabile in casi in cui:

• Il numero di sottoproblemi e' polinomiale
• La soluzione del problema puo' essere facilmente calcolata dalle soluzioni ai sottoproblemi
• Vi e' un ordinamento naturale di sottoproblemi dal piu' piccolo al piu' grande con sottoproblemi facili da calcolare.

Caratteristiche

• Iterativa nell'implementazione, ricorsiva nell'espressione dell'equazione alle ricorrenze
• Bottom-up

Note su Backtracking / Branch and Bound

Backtracking

Il backtracking e' una tecnica che permette la wicerca esaustiva (brute-force) esplorando sistematicamente lo spazio degli stati. A differenza della semplice ricerca esaustiva (che prova tutte le possibilita'), il backtracking riduce il numero di tentativi effettuati utilizzando un vettore componente e delle funzioni criterio (bounding functions) per verificare se una soluzione parziale puo' generare una soluzione accettabile.

Caratteristiche

• Si applica a molti problemi che richiedono un insieme di soluzioni che soddisfino una serie di vincoli. I vincoli espliciti identificano lo spazio delle soluzioni.
• Ricorsiva nell'implementazione, per generare un albero degli stati.
• Caratterizzata da una chiamata che esplora l'albero degli stati ricorsivamente resettando lo stato precedente quando ritorna, di modo da considerare tutte le possibili soluzioni.
• Problema: la ricerca esaustiva spesso esplora stati ridondanti. Per questo si ricorre a soluzioni di potatura dell'albero delle soluzioni, tra cui:
  1. Rimozione di simmetrie (i.e. evitare che i cicli vengano percorsi in entrambe le direzioni nel ciclo hamiltoniano) -> forzare un ordine
  2. Individuare soluzioni poco promettenti (che certamente non portano a una soluzione) Le funzioni di bounding sono utilizzate in questo contesto per ridurre lo spazio degli stati.

Calcolo dell'efficienza

L'efficienza di un algoritmo backtracking dipende da:

• Il tempo per generare il valore successivo nel vettore soluzioni s.
• Il numero di valori di s che soddisfano i vincoli espliciti.
• Il tempo per il calcolo delle funzioni di bounding.
• Il numero di valori in s che soddisfano le funzioni di bounding.

Si nota che due diverse istanze dello stesso problema possono portare lo stesso algoritmo di backtracking a una soluzione lineare O(n) e a una soluzione esponenziale / fattoriale. Questo perche' la generazione dello spazio degli stati in alcuni problemi significa generare tutte le combinazioni / permutazioni di un certo input, ottenendo complessita' elevate. Per questo si utilizzano funzioni di bounding, che riducono tramite dei vincoli il problema.

Teorema

Se definiamo:

• h: altezza albero delle soluzioni
• O(f(n)): tempo richiesto dalla visita di un nodo interno all'albero delle soluzioni
• O(g(n)): tempo richiesto dalla visita di una foglia dell'albero (soluzione)
• D(n): numero di soluzioni

Possiamo dire che visitare solo nodi nei cui sottoalberi e' presente una soluzione richiede tempo:

O(h*f(n)*D(n) + g(n)*D(n))

Nota: questo teorema NON FUNZIONA se la funzione di bounding non assicura che un nodo venga visitato solo se il sottoalbero contiene soluzioni. vedi Ciclo Hamiltoniano.

Branch and Bound

Generalizzazione del backtracking ai problemi di ottimizzazione. Tecnica che permette di calcolare i limiti per le soluzioni parziali al fine di contenere il numero di soluzioni complessive che derivano dall'esplorazione completa dell'albero delle soluzioni. Si divide in due parti:

1. Branch: regola che determina il sottoalbero delle scelte da analizzare
2. Bound: regola che determina il lower bound per ogni nodo dell'albero, generando un minimo sotto al quale i costi delle soluzioni non scendono. Questo permette di escludere quelle che di sicuro portano a una soluzione peggiore dell'attuale.

Caratteristiche

• Come backtracking esplora tutto l'albero delle soluzioni, ma si applica a problemi di minimizzazione
• Mantiene sempre la migliore soluzione ammissibile tra quelle esaminate
• Non genera i sottoalberi di scelte per i nodi che non possono migliorare la soluzione ottima attuale.
• Tecnica ulteriore di potatura: Se si considera un percorso di costo c, non ha senso continuare la ricerca su percorsi con costo maggiore di c.
• Come per il backtracking, il caso peggiore risulta avere complessita' nel tempo super-polinomiale.

Lower bound

Il calcolo del lower bound dipende dalla sequenza di scelte fatte e deve garantire che tutte le soluzioni ammissibili generabili da quella sequenza abbiano un costo maggiore a LB(x).

Si assegna un rango ai nodi sulla base dello sforzo computazionale aggiuntivo per raggiungere dal nodo considerato il nodo risposta. Questo significa considerare:

1. Il numero di nodi nel sottoalbero da generare per ottenere un nodo risposta
2. Il numero di livelli per cui un nodo risposta dista dal nodo

Queste sono funzioni di costo ideali, nel senso che per determinare il rango esatto con queste funzioni, e' necessario esplorare l'intero sottoalbero. Dato che questo vanificherebbe lo scopo del bounding, si utilizzano ranghi basati su una stima del costo.

Costo di un nodo X:

C[s](X) = f(h(X)) + g[s](X)

Dove:

• f() e' una funzione non decrescente
• h(X) e' il costo per raggiungere X dalla radice
• g[s](X) e' il costo stimato necessario a raggiungere un nodo risposta da X.

Least-Cost Search

La strategia di ricerca (FIFO / LIFO) si chiama Least Cost Search, perche' come nodo successivo viene scelto quello vivo con C[s] minore.

• FIFO (Breadth-first): LC-s con g[s](X) = 0 e f(h(X)) = level(X)
• LIFO (Depth-first): LC-s con f(h(X)) = 0 e per ogni Y figlio di X, g[s](X) >= g[s](Y) (dato che Y e' piu' vicino a un nodo risposta rispetto a X)

Algoritmi di Approssimazione

Se garantire l'ottimalita' di una soluzione per un problema NP-completo richiede un tempo di calcolo troppo elevato, si ricorre ad una soluzione sub-ottima calcolabile in tempo polinomiale. Per questi casi si usano algoritmi di approssimazione che esprimono la distanza tra soluzione teoricamente ottima e approssimata con un rapporto limite.

Rapporto Limite

Se I e' un problema di ottimizzazione, allora S(I) e' l'insieme di soluzioni ammissibili:

• Ad ogni soluzione ammissibile S di I, si associa un costo C(I,S) che per i problemi di minimizzazione sara' il minimo tra tutte le soluzioni ammissibili, viceversa per i problemi di massimo.

Definiamo quindi il rapporto limite come la massima distanza tra il costo di una soluzione prodotta dall'algoritmo approssimato e una prodotta dall'algoritmo ottimale. (un po' come il competitive ratio)

Per gli algortmi approssimati, il rapporto limite e' sempre maggiore di 1. Piu' alto e' il rapporto, peggiore e' la soluzione approssimata.

Schemi di approssimazione

Tecniche che garantiscono di poter calcolare (e contenere entro un certo valore) il rapporto limite.

1. Greedy: Si deve comunque trovare una regola che porti vicini alla soluzione ottima.
2. Pricing: si considera un costo da pagare per ogni vincolo del problema da rinforzare.
3. Programmazione lineare
4. Programmazione dinamica su una versione arrotondata dei dati in input.

Appossimazione e Riduzione polinomiale

La teoria della complessita' dice che e' possibile ridurre un problema a un altro in NP, (si pensi a Cook-Levin). Per i problemi di approssimazione bisogna pero' considerare che alcune volte non e' possibile ridurre un algoritmo approssimato ad un altro. Questo perche' i fattori di approssimazione possono cambiare tra un problema e l'altro.

Scheduling di intervalli

In versione pesata e non pesata.

• Greedy (intro pr.din 1) solo non pesati: con gli intervalli pesati, l'algoritmo greedy non funziona. Funzionamento: si riordinano gli intervalli per tempo di fine crescente. Da questo set ordinato si prendono uno alla volta gli intervalli e li si inserisce all'interno della soluzione. In questo la complessita' massima e' O(nlogn) a causa dell'ordinamento.

• Dinamica (intro pr.din 1) - intervalli pesati: utilizzato per introdurre il paradigma di programmazione dinamica, l'equazione alle ricorrenze e il memoizing. Si utilizzano intervalli con peso numerico e si vuole massimizzare la somma dei pesi degli intervalli selezionati tra i compatibili (non sovrapposti).

  • Sottoproblemi: i sottoproblemi sono soluzioni ottime in un subset degli intervalli. Definiamo un intervallo come appartenente a una soluzione ottima su un set di intervalli se soddisfa l'equazione alle ricorrenze:

    v[j] + OPT(p(j)) >= OPT(j-1)        // j e' l'intervallo considerato
    

    Questo significa che un intervallo appartiene alla soluzione ottima se il suo peso migliora la soluzione ottima precedente OPT(j-1). Si nota che in questo caso p(j) e' l'indice dell'ultimo intervallo i tale che i e j sono disgiunti.
  • Complessita': L'algoritmo richiede tempo esponenziale nel caso peggiore (intervalli ordinati in modo decrescente per tempo di fine, slides). Questo e' dovuto al fatto che calcolare i sottoproblemi ricorsivamente genera un albero di sottoproblemi ridondante.
  • Memoizing: usato per risolvere il problema della ridondanza. Si utilizza un array M che viene riempito iterativamente memorizzando i pesi ottimali. Questo significa che i valori precedenti (OPT(j-1) in particolare) non vengono ricalcolati ma semplicemente letti dall'array (accesso O(1) in quanto si conosce l'indice). Cosi' facendo, si ottiene la soluzione ottima in un tempo O(n). Memoizing:

    M[j] <-- max(v[j] + M[p(j)], M[j-1]  //si nota come p(j) restituisca l'indice
                                           dell'elemento compatibile
    

Cammini minimi in un DAG / grafo con cicli positivi

• Dinamica (intro pr.din 2): questo algoritmo e' importante perche' illustra la strategia di programmazione dinamica quando si presentano scelte multiple: ad ogni passo non abbiamo piu' due possibilita' ma un numero polinomiale di esse. Si consideri un grafo orientato, aciclico, pesato in cui si vogliono trovare i cammini di lunghezza minima dato un nodo di origine.

  • Sottoproblemi: Per ogni nodo v, la distanza minima dal nodo di origine sara' il minimo tra le distanze minime dall'origine dei suoi predecessori.

    dist(v) = min{ dist(u) + w(u,v) | (u,v) in E }  // w e' la funzione di peso, dist(s) = 0
    

    Se si considerano i nodi da sinistra a destra (vedi ordinamento topologico), quando si ha un nodo v si dispone anche delle informazioni per calcolare dist(v), essendo che per i predecessori la distanza minima e' gia' stata calcolata.
  • Complessita': la complessita' nel caso peggiore e' data dalla somma della complessita' dell'ordinamento topologico e dal numero di confronti per calcolare le distanze. Si ottiene:

    O(V+E) + O(V^2) --> O(V^2)
    

  • Note: in questo caso non si usa la struttura dati del DAG, che rimane implicita: i nodi del dag sono sottoproblemi e gli archi le dipendenze da essi.

• Dinamica (cammini minimi e prodotto di matrici): Variante. Trovare il peso dei cammini di peso minimo tra tutte le coppie di vertici di un grafo orientato e pesato, supponendo che non ci siano cicli di peso negativo. In questo caso i cicli positivi sono permessi.

  • Sottoproblemi: si definiscono i cammini minimi in funzione della lunghezza dei cammini, sapendo che:
    1. Un cammino inesistente ha peso infinito.
    2. Non esiste cammino lungo 0 archi tra due vertici diversi.
    3. Un singolo nodo ha un cammino lungo 0 che porta a se stesso
    4. Il cammino di peso minore tra due nodi distinti di lunghezza al piu' m e' un cammino di lunghezza minore di m, oppure un cammino di lunghezza m ottenuto da un cammino minimo di lunghezza m-1 fino a un vertice predecessore, seguito dall'arco che collega il predecessore al nodo destinazione.

    D(0)[i,j] = 0 se i == j OPPURE infinito se i != j
    
    D(m)[i,j] = min{ D(m-1)[i,k] + W[k,j] } for k in 1..n
    
    D(1) = W
    

  • Memoizing: Si utilizza una matrice di vertici x vertici (quadrata) in cui si memorizzano i cammini di lunghezza minima da ogni vertice a ogni altro.
  • Complessita': O(n^3) dato che dobbiamo iterare su ogni cella della matrice e per ognuna cercare il minimo cammino (O(n)) Se si vuole mostrare tutte le coppie e' necessaria un'ulteriore iterazione, ottenendo complessita O(n^4)
  • Variante Efficiente: Se m e' pari, un cammino minimo tra due vertici i,j sara' scomponibile in due cammini di lunghezza al piu' m/2. Possiamo quindi modificare l'equazione alle ricorrenze:

    D(m)[i,j] = min{ D(m/2)[i,k] + D(m/2)[k,j] } per m > 1
    
    D(1)[i,j] = W[i,j]
    

    La procedura viene impostata in forma iterativa con l'algoritmo visto in precedenza, solo che la divisione dell'intervallo abbassa la complessita': l'algoritmo e' O(n^3*log2(n))
  • Floyd-Warshall: Utilizza la numerazione dei vertici tra 1..n e definisce il cammino tra due vertici in funzione dei vertici attraversati dal cammino. In questo modo il cammino tra i,j di peso minore che attraversa al piu' i vertici 1..k e' un cammino che attraversa al piu' i vertici 1..k-1 oppure un cammino che attraversa k ottenuto concatenando un cammino minimo tra i,k e un cammino minimo tra k,j.

    D(m)[i,j] = W[i,j] se m == 0
    
    OPPURE
    
    D(m)[i,j] = min{ D(m-1)[i,j], D(m-1)[i,m] + D(m-1)[m,j] } se m > 0
    

    Questo algoritmo ha complessita' O(n^3)

Lunghezza massima di una sottosequenza crescente

• Dinamica (intro pr.din. 2): Data una sequenza di numeri, determinare la sottosequenza crescente piu' lunga al suo interno. Questo problema puo' essere rappresentato da un grafo che associ ad ogni vertice un elemento della sequenza, utilizzando un arco orientato per indicare se un elemento ne precede un altro all'interno della sequenza. Si riconduce quindi il problema al DAG, in cui si deve trovare il cammino massimo.
  • Sottoproblemi: definendo il massimo su un insieme vuoto come 0:

  L(j) = max{ L(i) | i<j && X[i] < X[j]} + 1        // aggiungiamo 1 perche' si inserisce un
                                                       elemento alla volta
  

  • Complessita': L'algoritmo ricorsivo genera un albero di sottoproblemi ridondante con numero di nodi esponenziale in n. Per questo si adotta l'algoritmo iterativo che si avvale del memoizing (specialmente nel caso in cui si voglia salvare anche la sottosequenza e non solo la sua lunghezza).

Scheduling (variante di scheduling di intervalli)

Si consideri il problema in cui le richieste in uso di una risorsa sono specificate da una durata e debbano essere soddisfatte entro un particolare intervallo di tempo.

• Dinamica (pr-dinamica-zaino): In questo problema si mostra come l'insieme ovvio dei sottoproblemi alle volte non sia sufficiente e si debba creare una collezione di sottoproblemi piu' ricca.
  • Sottoproblemi: Come nel caso precedente, due casi:
    1. Se la richiesta non appartiene alla soluzione ottima, OPT(n) = OPT(n-1)
    2. Se la richiesta appartiene alla soluzione ottima, vogliamo trovare il miglior valore tra tutte le soluzioni che la contengono come ultima richiesta. Sono necessari piu' sottoproblemi che negli intervalli pesati semplici, dato che si vuole conoscere la miglior soluzione nelle n-1 richieste con tempo W - w[n] Si risolve un sottoproblema per ogni insieme di richieste e ogni possibile valore di tempo restante.

    OPT(i,w) = max_S{ sum in j of w[j] for j in S}
    
    quindi:
    
    if (w < w[i]) {
        OPT(i,w) = OPT(i-1,w)
    else
        OPT(i,w) = max{ OPT(i-1, w), w[i] + OPT(i-1, w-w[i]) }
    

    In questo caso e' necessario confrontare i valori ottenuti includendo ed escludendo il nodo i. L'algoritmo e' chiamato Subset-Sum e fa uso di memoizing per i tempi.
  • Complessita': Subset-sum ha complessita' O(nW) per calcolare il valore ottimo, ma data una tabella di valori ottimi dei sottoproblemi, questo si riduce a O(n).

Zaino 0/1

Knapsack problem classico con uno zaino di capacita' C e n oggetti O[1..n]. Dato ogni oggetto con un peso e un valore, si deve selezionare un sottoinsieme degli oggetti da inserire nello zaino per massimizzare il valore del contenuto. Molto simile a scheduling.

• Dinamica (pr-dinamica-zaino): Si suppone un vettore p di pesi e un vettore v di valori, con i quali si considerano i seguenti sottoproblemi.

  • Sottoproblemi: Se l'i-esimo oggetto non sta nello zaino, allora:

    Val(i,k) = Val(i-1,k) se i,k != 0 and k < p[i]      // k e' la capacita' attuale
    

    Se invece entra nello zaino:

    Val(i,k) = max{ Val(i-1,k), Val(i-1, k-p[i]) + v[i] } se i,k != 0 and k >= p[i]
    

    Anche qui, come nello scheduling, e' necessario confrontare i valori ottenuti includendo ed escludendo l'oggetto considerato. Questo e' dovuto al fatto che anche se un oggetto entra nello zaino, non e' per forza la soluzione ottima assoluta del problema.
  • Memoizing: in questo caso si utilizza una matrice di indici/capacita' per salvare i valori corrispondenti.
  • Correttezza: sappiamo che la definizione data e' corretta perche' applica una proprieta' essenziale, ovvero che se uno zaino di dimensione k e' riempito nel modo ottimo con l'oggetto i, allora lo zaino di dimensione k-p[i] e' riempito in modo ottimo con gli oggetti 1..(i-1).
  • Complessita': O(nC)

• Backtracking (3.Zaino-0-1...): Si utilizza un vettore soluzione e un adiacente vettore Sol per salvare la soluzione migliore attualmente trovata.

  • Bounding: Si ipotizza un vettore peso e un vettore valore, entrambi ordinati in modo non crescente. La funzione di bound determina un upper bound sulla migliore soluzione ottenibilie in base ai vincoli:
    1. inserire un oggetto nello zaino significa potare i sottoalberi sinistri: si richiede che il peso degli oggetti nello zaino sommato a quello dell'oggetto considerato non superi la capacita'.
    2. scartare un oggetto dallo zaino significa potare i sottoalberi destri: si cerca un limite superiore al valore raggiungibile senza considerare l'oggetto stesso. Si nota come questo algoritmo sia una ricerca in profondita' con vincoli aggiunti.

• Branch and bound (4.BB.2.1.pdf): Utilizzato per il confronto con l'algoritmo di backtracking (sopra). Si mantiene l'ipotesi dei vettori ordinati in maniera non crescente. Si deve pero' impostare il problema come un problema di minimo.

  • Funzione obbiettivo da minimizzare:

  (minus) sum for i in [1,n] of: V[i]*S[i] = C(X)
  // somma negativa dei valori corrispondenti agli elementi della soluzione.
  // si utilizza come funzione di costo per tutti i nodi foglia
  
  Con vincolo:
  
  sum for i in [1,n] of: P[i]*S[i] <= C
  // la somma dei pesi degli elementi della soluzione non deve eccedere la capacita'
  
  

  • Quindi e' possibile definire il costo come la funzione obbiettivo nel caso in cui la soluzione sia accettabile (somma dei pesi minore di capacita'), mentre il costo e' infinito se il nodo non appartiene a una soluzione accettabile. Funzione di costo per i nodi interni:

  C(X) = min{ C(left(X)), C(right(X)) }
  

  • Questo e' il lower bound di C(X) per ogni nodo X, per cui puo' essere usata come funzione di lower bound C[S](X)
  • L'algoritmo utilizza la tecnica greedy per migliorare il valore attuale della soluzione provvisoria. (sceglie l'elemento migliore dal punto di vista del valore).
  • La funzione di upper bound puo' essere trovata considerando che se si riempie lo zaino alla cieca si ottiene il risultato peggiore. L'alternativa semplice e' utilizzare la funzione obbiettivo su ogni nodo a livello j.
  • Confronto con backtracking

Zaino con Ripetizione

Estensione dello zaino 0/1 in cui sono permesse ripetizioni di elementi. Il problema si semplifica in quanto non serve l'informazione sugli oggetti usati. Aumenta pero' il numero di scelte (da due -> scheduling a multiple)

• Dinamica (pr-dinamica-zaino): Si utilizzano sottoproblemi dipendenti unicamente dalla capacita' dello zaino.

  • Sottoproblemi: A differenza dello zaino 0/1, ora non consideriamo piu' il caso k < p[i] perche' abbiamo potenzialmente un numero infinito di oggetti.

    Val(k) = max{ Val(k-1), max{ Val(k-p[i]) + v[i] | p[i] <= k } } se k != 0
    

    Per ogni oggetto, dobbiamo contollare il massimo valore ottenibile con gli oggetti a disposizione, e poi controllare di aver migliorato la soluzione precendente, ossia quella in cui la capacita' era ridotta di 1. Si nota come l'algoritmo iteri sulle capacita' di modo da calcolare i casi migliori con le capacita' minori e procedere con memoizing.
  • Complessita': O(nC)

• Greedy (pr-dinamica-zaino), oggetti continui: in questo caso riempiamo lo zaino partendo dagli elementi piu' preziosi. Solo algoritmo.

Moltiplicazione di matrici

Date n matrici, determinare una parentesizzazione del prodotto A1*A2*..An che minimizzi il numero di moltiplicazioni scalari.

• Dinamica (Cammini minimi e prodotto di matrici): Si comincia considerando quante e quali sono le possibili parentesizzazioni di n matrici. La funzione P(n) indica il numero di parentesizzazioni per A1*A2*..An. Si nota che l'ultima moltiplicazione puo' occorrere per n-1 posizioni diverse. Fissiamo quindi l'indice k dell'ultima moltiplicazione, per considerare P(k) parentesizzazioni fino ad Ak e P(n-k) parentesizzazioni per A(k+1)..An. Si ottiene:

  P(n) = sum for k from 1 to n-1 of:    P(k)*P(n-k)         // definizione di numeri catalani
  

  Possiamo quindi dire che P(n) ha lower bound Ω(2^n). L'approccio brute-force risulta quindi troppo costoso. Si cerca di ricavare dei sottoproblemi per applicare la pr. din.
  • Sottoproblemi: Se si considera una sottostruttura (parentesizzazione) ottima del prodotto tra Ai*..*Aj, allora A[i..k] e A[k+1..j] sono parentesizzazioni ottime dei rispettivi prodotti (Ai*..*Ak e A(k+1)*..*Aj). Questo puo' essere dimostrato per assurdo. Si puo' quindi definire il numero minimo di prodotti scalari:

    m(i,j) = m(i,k) + m(k+1,j) + c[i-1]*c[k]*c[j]   // dove c.. sono il numero di prodotti
                                                       per moltiplicare le rispettive 
                                                       matrici.
    

    Dato che il valore di k non e' noto a prescindere ma si sa che e' compreso tra i,j-1, allora li si prova tutti:

    m(i,j) = min{ m(i,k) + m(k+1,j) + c[i-1]*c[k]*c[j] } per k in [i,j]
    

  • Complessita': se si utilizza l'approccio top-down, si ha complessita' Ω(2^n). Dato che l'albero delle soluzioni calcolato a brute-force risulta in molte computazioni ridondanti, si applica la pr. dinamica. Questo permette di ridurre il numero di problemi calcolati secondo la formula:

    binomial(n, 2) + n = O(n^2)     // binomial.. sono i sottoproblemi con i != j
                                       n sono i sottoproblemi con i == j
    

    L'algoritmo risultante (Matrix-chain-order) ha complessita' O(n^3).
  • Memoizing: Il calcolo bottom-up richiede una matrice nxn per ricordare i valori dei sottoproblemi risolti. Il prodotto viene effettuato sempre tra una matrice di indice inferiore e una di indice superiore, pertanto serve unicamente il triangolo superiore della matrice.
  • Memorizzare la sequenza di moltiplicazioni: si utilizza un algoritmo ricorsivo che utilizza la matrice soluzione per memorizzare la posizione k della parentesizzazione.

Distanza di matching (edit)

Misurare la distanza tra due stringhe. Uno dei modi piu' semplici e' allinearle e controllare lettera per lettera se un carattere e' match oppure no. Il valore associato all' allineamento (costo) e' il numero di operazioni necessarie per allineare le stringhe.

• Dinamica (distanza di edit): la distanza di edit si presenta quindi come il costo del miglior allineamento. Essendo che controllare tutti i possibili allineamenti e' un problema combinatorio (esponenziale in tempo), possiamo definire dei sottoproblemi per la pr.din.
  • Sottoproblemi: date due stringhe, si considerino due caratteri a[i],b[j]. Per allinearle ci sono 3 opzioni (nell'allineamento migliore):
    1. l'ultima lettera della stringa a, ovvero a[n], e' successiva all'ultima lettera della stringa b, ovvero b[m]. Costo: C[a[1..n-1]] + C[b[1..m]] + delta.
    2. Il contrario di 1, ossia b[m] successiva ad a[n]. Costo: C[a[1..n]] + C[b[1..m-1]] + delta
    3. a[n],b[m] coincidono. Costo: C[a[1..n-1]] + C[b[1..m-1]] + alpha[n,m] dove alpha e' 0 se a[n] == b[m] Questo porta alla seguente definizione di equazione alle ricorrenze:

    E(i,j) = min{ delta + E(i-1,j), delta + E(i,j-1), alpha[i,j] + E(i-1,j-1) }
    
    dove alpha[i,j] = 0 se a[i] == b[j], altrimenti != 0 se sono diverse.
    
    Nota: E(i,j) e' il costo della distanza di edit tra a[1..i] e b[1..j]
    

  • Memoizing: si utilizza una matrice (n+1)x(m+1) per memorizzare la distanza di edit ottimale per ogni sottostringa a[1..i],b[1..j]. La risultante tabella puo' essere ripercorsa all'indietro per ottenere un risultato ottimale. (slides)
  • Complessita': L'algoritmo iterativo ha complessita' O(nm).
  • String matching approssimato: se si considera il problema di trovare un'occorrenza di una data stringa in un testo, ammettendo i seguenti errori:
    1. Caratteri corrispondenti nella stringa e nel testo possono essere diversi.
    2. Uno/piu' caratteri della stringa non compaiono nel testo.
    3. Uno/piu' caratteri del testo non compaiono nella stringa. Definiamo quindi un occorrenza n-approssimata quella in cui abbiamo un match preciso a n caratteri diversi. (2-approssimato -> 2 caratteri diversi, etc). L'algoritmo risultante e' simile alla distanza di edit, con la stessa complessita' nel tempo.

String Matching (KMP)

Data una stringa e un testo, si vogliono trovare tutte le occorrenze esatte della stringa nel testo. A differenza della distanza di edit / matching approssimato, qui non si considerano errori nel matching.

• Backtracking (KnuthMorrisPratt): il metodo piu' naif consiste nell'allineare i caratteri di sinistra della stringa e del testo finche non si trova un'occorrenza della stringa / si trovano due caratteri diversi (che negano l'occorrenza). Si ricomincia quindi con la stringa fatta avanzare verso destra di un carattere.
  • Problema: numero di confronti molto elevato nel caso di match parziali. O(nm). Questo puo' essere ridotto a O(n+m) spostando la stringa di piu' di un carattere in presenza di un errore oppure riducendo i confronti saltando alcune parti dopo lo shift.
  • Si nota che solo il pattern aiuta a calcolare l'indice da cui ricominciare il confronto mentre sul testo non e' necessario backtracking.
  • Se si tiene da conto il numero di posizioni da attraversare nel caso si incontri un errore, possiamo utilizzare quest'informazione per ridurre il numero di iterazioni necessarie. Questo significa che al momento dell'errore non si ricomincia con la stringa da capo ma si torna all'ultimo carattere che potrebbe dare un match (l'ultimo uguale).
  • Si tratta di un automa che effettua transizioni all'indietro per tutti i simboli che non permettono un match del pattern, fino all'ultimo carattere uguale che potrebbe permettere un match.

Commesso Viaggiatore

Il commesso viaggiatore e' un problema che si presenta in questo modo: Data una lista di citta' e distanze tra ogni coppia di citta', qual'e' la strada piu' corta possibile per visitare tutte le citta' e tornare alla citta' di partenza? Si identifica quindi come il problema di trovare cicli di costo minimo a partire da un dato vertice.

Formulazione grafi: Dato un grafo non orientato, completo, e pesato, trovare un ciclo semplice che contenga tutti i vertici del grafo e sia di costo minimo.

• Dinamica (CommViaggDin): si parte considerando g(i,S), ossia una funzione che ritorna il costo di un cammino minimo dal vertice i al vertice 1 che attraversa una sola volta i vertici in S. Pertanto, il ciclo minimo sara' g(1, V-{1}), ovvero il cammino minimo che torni al vertice di partenza (da 1 a 1) passando una sola volta da tutti i vertici a parte 1.

  • Sottoproblemi: per il principio di ottimalita', possiamo definire per ogni i non appartenente al set S (a cui viene poi aggiunto all'iterazione successiva):

    g(i,S) = min{ d[i,j] + g(j,S-{j}) } con S non vuoto e j in S.
    
    Si nota che g(i, S=vuoto) = d[i,1]      // la distanza tra i e 1 se non vi sono vertici
                                               in mezzo.
    

    La soluzione finale sara' quindi:

    g(1,V-{1}) = min{ d[1,k] + g(k,V-{1,k}) } con k in [2..n]
    

  • Memoizing: si utilizza una tabella per memorizzare le lunghezze minime di un cammino semplice da i a 1 in S (su slides gtab).
  • Complessita': l'algoritmo in programmazione dinamica si basa sul calcolo di g(i,S), il che richiede un gran numero di confronti: O(n^2*2^n). Si nota come questa complessita' sia in realta' vantaggiosa rispetto alle implementazioni in branch&bound / backtracking, che permettono di ottenere un caso peggiore O(n!). La complessita' nello spazio delle strutture dati e' critica nel caso della prog.din: O(n*2^n).

• Branch and Bound (4.BB.2.1): Si comincia definendo il costo dei nodi. La funzione C(X) avra' quindi due differenti significati:

  • Se X e' foglia, allora C(X) e' il costo del cammino ciclico individuato (soluzione)
  • Se X e' interno, allora C(X) e' il costo della foglia di costo minimo nel sottoalbero di X Si cercano quindi due funzioni per cui C[s](X) <= C(X) <= u(X).
  • C[s](X) puo' essere definita considerando che C(X) per la soluzione parziale dalla radice al vertice X e' dato almeno da:

    C(X) = sum for j in [1..(i-1)] of: d(S[j], S[j+1])
    

    Sappiamo che ogni cammino ciclico che inizia con S[1..i] non puo' avere peso minore di:

    C[s](X) = C(X) + floor( A + B + sum for h not in S of: D[h])/2 // se X non foglia
    
    C[s](X) = C(X) + d[S(i), S(1)]  // se X e' una foglia
    
    - dove:
        A = min{ d[S[i], h] } con h not in S
        // l'arco di lunghezza minima da un nodo di S[1..i] a h
    
        B = min{ d[S[1], h] } con h not in S
        // l'arco di lunghezza minima da un vertice h non in S al nodo di origine
    
        D[h] = min{ d[h,p] + d[h,q] } con h != p != q, h not in S ma p,q possono appartenere
        // ogni vertice in h not is S dovra' essere attraversato, quindi estremo di due archi
        (h,p) e (h,q)
    
        A + B + somma per h non in s di: D[h] = peso di 2+2k = 2(k+1) archi
        // k e' il numero di vertici non in S
    
    - A questi archi ne vanno aggiunti ancora k+1 per chiudere il ciclo, ma il loro peso non
      e' inferiore alla meta' di quello dei 2(k+1) archi
    
    Quindi C[s](X) e' definita come sopra in quanto valore minimo per C(X)
    

  Se si utilizza una variabile globale per salvare il costo della soluzione minima, si ottiene l'algoritmo.

Permutazioni

Generare tutte le possibili permutazioni di un dato valore in input, in cui i numeri dispari precedono i numeri pari. Esempio utilizzato per illustrare il principio di backtracking con vincoli.

• Backtracking (2.1.Backtracking): L'algoritmo e' ottenuto verificando che nella prima meta' del vettore soluzioni devono comparire solo numeri dispari e nella seconda solo numeri pari. Questo e' il vincolo esplicito che ci permette di ridurre lo spazio delle soluzioni.
  • Complessita': Senza vincoli, O(n!), con vincolo pari/dispai invece proporzionale al numero di permutazioni da generare.

Sottoinsiemi

Dati due interi n,c, generare tutti i sottinsiemi di {1..n} di cardinalita' c.

• Backtracking (2.1.Backtracking): La ricerca della soluzione avviene esaminando tutti i sottinsiemi di {1..n} e verificando quali hanno cardinalita' c. Applicazione diretta della ricerca esaustiva.
  • Complessita': Il tempo di esecuzione e' O(n2^n), dato che la generazione dello spazio degli stati richiede tempo esponenziale in 2^n e il calcolo del numero di elementi al piu' n. Si nota come gli insiemi da generare sono binomial(n,c) e quindi O(n^c), per cui quanto piu' c e' piccolo rispetto a n tanto piu' l'algoritmo e' inefficiente. Sono necessarie funzioni di bounding:
  • Bounding: Per potare l'albero delle scelte, si eliminano i seguenti sottoalberi:
    1. Quelli in cui sono stati inseriti piu' di c elementi
    2. Quelli in cui il numero degli elementi della soluzione parziale piu' il numero di elementi non considerati e' minore di c. Le funzioni di bounding decideranno quindi:
    3. Se escludere l'elemento i-esimo non preclude la possibilita' di ottenere una soluzione, allora si visita il sottoalbero destro
    4. Se aggiungere l'elemento i-esimo non genera una soluzione parziale con piu' di c elementi, allora si visita il sottoalbero sinisto. Questo significa che ogni nodo viene visitato solo se nel suo sottoalbero e' presente almeno una soluzione. Dal teorema sopra citato, si ottiene costo in tempo:

    O(n*n^c) = O(n^(c+1))
    

Cicli Hamiltoniani

Dato un grafo non orientato, esiste un ciclo semplice che contiene tutti i nodi? Nota: semplice => ogni nodo una volta sola.

• Backtracking (1.Backtracking-intro): Si considera un vettore di nodi i cui posti !=0 indicano che il nodo e' stato visitato, 0 altrimenti. L'algoritmo fa uso delle funzioni di bounding per potare l'albero delle soluzioni da simmetrie (cicli in un senso o nell'altro) ed escludere i percorsi che dividono il grafo di modo che un ciclo semplice non sia piu' possibile.

Somma di sottoinsieme

Dati un insieme e un intero, trovare tutti i sottoinsiemi la cui somma degli elementi sia l'intero.

• Backtracking (2.2.Backtracking): I sottoinsiemi sono rappresentati da un vettore i cui elementi possono assumere il valore 0 per l'elemento presente e 1 per il valore assente.
  • Bounding: la funzione di bounding e' analoga a quella per i sottoinsiemi di cardinalita' fissa:

    B(X[1]..X[i]) = Sum for k in [1..i] of W[k]*X[k] +
                        Sum for k in [i+1..|W|] of W[k] >= M
    
    Dove M e' l'intero considerato.
    

    Questo assicura che non si considerino sottoalberi che non possono portare a M. Inoltre se si considera vettori in ordine non decrescente si puo' utilizzare la seguente funzione di bounding:

    Sum for k in [1..i] of W[k]*X[k] + W[i+1] <= M
    

    Questo assicura che non si considero sottoalberi che superino M.

Colorabilita' dei grafi

Dato un grafo trovare tut i i modi in cui e' possibile colorare i vertici di esso in modo che i vertici adiacenti abbiano colori diversi.

• Backtracking (2.2.Backtracking): L'algoritmo utilizza un vettore X per associare colori a vertici. La procedura prova ad assegnare al nodo i-esimo ogni colore supponendo che siano tutti compatibili, richiamandosi sul nodo successivo ricorsivamente. I controlli fanno si' che le combinazioni che non portano a soluzione siano escluse in quanto non vanno a buon fine. Si nota come in questo algoritmo non siano presenti procedure di reset ma check che a priori escludono soluzioni (combinazioni di colori) non valide.
  • Complessita': La verifica di ogni scelta richiede controlli di complessita' trascurabile, per cui se il numero di chiamate ricorsive di Color(i) e' C(i):

    C(1) = m*C(2) = m*m*C(3) = ... m^n --> O(m^n)   // m = numero di colori, n = numero nodi
    

N Regine

Data una scacchiera NxN, si posizionino su di essa N regine di modo che nessuna di esse sia sotto scacco. (una per riga, una per colonna, una per diagonale).

• Backtracking (2.2.Backtracking): in questo caso il vincolo esplicito e' che nessuna regina sia sulla stessa riga, mentre il vincolo implicito e' che nessuna sia sotto scacco. Per questo si ricorre sulle righe utilizzando come insieme delle scelte le colonne 1..N. Si ricorre unicamente se la posizione i, X[i] e' sicura, di modo da generare solo le disposizioni ammesse e stamparle.
  • Verifica: La parte complessa dell'algoritmo qui risiede nella verifica di una diagonale libera, in quanto le colonne libere sono facili da verificare. Si nota che la differenza degli indici di una diagonale discendente e' costante, mentre la somma degli indici di una diagonale discendente e' anch'essa costante. Questo permette di verificare le colonne. Ci sono formulazioni alternative.

Load Balancing

Dato un insieme finito di programmi, tali che ogni programma richiede un tempo intero di esecuzione, e m processori, eseguire tutti i programmi sui processori nel minor tempo possibile.

• Approssimata/Greedy (algoritmi-di-approssimazione-I): il problema richiede di minimizzare il massimo carico su ogni macchina (makespan). L'algoritmo piu' semplice considera i lavori in ordine qualunque e si assegna un lavoro alla volta alla macchina piu' scarica in quel momento. Non si arriva alla soluzione ottima (greedy), quindi si analizza il makespan.
  • rapporto limite: Se chiamiamo T il makespan greedy, dobbiamo calcolare anche T*, ovvero il migliore makespan possibile. Per trovarlo, si cerca un limite inferiore alla soluzione ottima, imponendo che ogni macchina svolga almeno 1/m del lavoro totale. Questo limite, aggiunto alla condizione che T* >= max[j] of t[j] (un lavoro molto piu' grande degli altri). Sappiamo che prima dell'assegnamento di un lavoro, la macchina scelta ha il minor carico tra tutte le macchine. Prima dell'assegnamento: T[i] = T[i] - t[j]

    Si sommano tutti i carichi:
    
    Sum for k in 1..n of T[k] >= m(T[i] - t[j])
    
    Che significa:
    
    T[i] - t[j] <= 1/m * (sum for k of T[k])
    

    Questa sommatoria equivale al **carico totale dovuto alle attivita' Sum of T[k] = Sum of t[j] Pertanto, per la prima funzione di lower bound:

    T[i] - t[j] <= 1/m * (sum for j of t[j]) <= T*
    

    Considerando la parte restante del carico su M[i], ovvero quello finale t[j], utilizziamo la seconda funzione di lower bound:

    t[j] <= T*
    

    Unendo le due disuguaglianze:

    T[i] = (T[i] - t[j]) + t[j] <= 2T*
    

    Che prova un rapporto limite = 2 (2T*/T*). L'algoritmo si avvicina a questo valore al crescere del numero di macchine. Questo puo' essere migliorato considerando i lavori ordinati in ordine decrescente di tempo. Si ottiene un rapporto limite di 3/2. Questo algoritmo ha complessita' O(nlogn) ed e' chiamato Largest Processing Time.

Center Selection

Si vogliono selezionare k centri dove costruire grossi centri commerciali e un insieme di S siti. Ogni individuo, residente in un sito, andra' in uno dei k centri (il piu' vicino).

Bisogna bilanciare la collocazione dei centi di modo da non sfavorire nessun sito. I siti sono collocati su di un piano e su qualsiasi punto di questo piano e' possibile collocare i centri.

• Approssimata/Greedy (algoritmi-di-approssimazione-I): Definiamo C un r-cover se:

  dist(s,C) <= r    for every s in S
  

  Il massimo valore di r per cui C e' un r-cover e' il raggio di copertura di C ed e' indicato con r(C). Questo rappresenta il percorso piu' lungo che ciascuno deve fare per giungere al centro commerciale piu' vicino.

  Bisogna quindi minimizzare r(C).

  La soluzione greedy propone di selezionare ogni sito senza considerare dove andranno collocati gli altri, cioe' per ogni centro ottimizzare la distanza tra tutti i siti. Questo pero' risulta in assegnamenti poco efficaci. Si sfrutta allora la conoscenza di r(C*) da una soluzione ottima C* per costruire una soluzione approssimata con:

  r(C) <= 2*r(C*)
  

  Nel caso in cui r(C*) non sia noto, si puo' procedere per tentativi effettuando una ricerca binaria che peo' aumenta di un fattore logaritmico la complessita'. Questa soluzione costruisce i centri commerciali nei siti stessi e non in punti qualunque del piano. La complessita' e' O(n*k).

Set Cover

Dati un insieme finito U e una famiglia di sottoinsiemi F di U tale che ogni elemento di U appartiene almeno ad un sottoinsieme di F.

Si vuole determinare una collezione di sottoinsiemi di F definita come copertura C se l'unione di tutti gli insiemi in C restituisce U. Si vuole inoltre trovare una collezione C di cardinalita' minima. Il costo di una soluzione ammissibile C e' |C|.

• Approssimazione/Greedy (algoritmi-di-approssimazione-I): Costruire la copertura un insieme alla volta, scegliendo ad ogni passo l'insieme che sembra migliore, ovvero quello che contiene il massimo numero di elementi non ancora coperti. Questa soluzione ha complessita' O(|U|*|F|*min{|U|,|F|}.

  • Rapporto Limite: Si distribuisce il costo unitario di ogni sottoinsieme della soluzione C sugli elementi che esso aggiunge alla copertura. (Se un set aggiunge 6 elementi, il peso di ogni elemento sara' 1/6) Si puo'quindi considerare:

    |C| = Sum for j in U of p[j]
    

    Da cui il costo dell'elemento j coperto da S[i] e':

    p[j] = 1 / |S[i] - (S[1] U S[2] ... U S[i-1])|
    

    La soluzione ottima comprendera' quindi tutti gli elementi di U almeno una volta.

    |C| = Sum for j in U of p[j] <= Sum for S in C* of (Sum for j in S of p[j])
    

    Essendo che uno stesso elemento in U puo' appartenere a piu' di un set in C*. Se S e' un qualsiasi elemento di F, il peso introdotto dalla soluzione C dell'algoritmo soddisfa:

    Sum for j in S of p[j] <= H(|S|)    // H e' la serie armonica arrestata ad |S|
    

    (vedi slides per catena disuguaglianze) Rapporto finale: H(max{ |S|: S in F }) = H(S*). Questo tempo di approssimazione non e' migliorabile in tempo polinomiale, a meno che P = NP.

• Approssimazione/Pricing (approssimati II): l'algoritmo greedy per i set pesati puo' anche essere visto come algoritmo di pricing: il costo di ogni sottoinsieme e' un costo di condivisione. Pertanto la definizione di greedy / pricing porta allo stesso problema in questo caso.

Copertura di vertici

Versione pesata. Trovare un insieme di vertici di un grafo che copra tutti gli archi del grafo, con peso minimo.

Il peso puo' essere definito come:

W(S) = Sum for i in S of w[i]

• Approssimati/Pricing (approssimati II): Per ogni vertice selezionato, si coprono tutti gli archi incidenti in quel vertice. Se carichiamo questi archi di un costo totale maggiore del costo del vertice, allora la procedura diventa unfair, mentre il prezzo p[e] puo' essere definito fair se il costo totale degli archi incidenti in i e' al massimo il costo del vertice stesso.

  Sum for e=(i,j) of p[e] <= w[i]   // Se la somma e' == w[i], il nodo e' tight
  

  Per ogni copertura di vertici S con prezzi positivi e fair, possiamo dire:

  Sum for e in E of p[e] <= Sum for i in S of (Sum for e=(i,j) of p(e)) <= W(S)
  

  L'algoritmo trova una copertura e attribuisce i costi, usandoli per guidare la selezione dei vertici. Da questo punto di vista l'algoritmo puo' essere considerato greedy.
  • Rapporto limite: L'insieme dell'algoritmo e' una copertura di vertici per cui:

  Sum for e in E of p[e] <= W(S)
  

  Questo vale anche per la copertura di costo minimo S*. Se consideriamo che tutti i nodi in S sono tight, ovvero la sommatoria e' esattamente w[i] per ogni nodo i in S e ogni arco puo' pagare al massimo due volte:

  W(S) = Sum for i in S of (Sum for e=(i,j) of p[e]) <= 2 * (Sum for e in E of p[e])
  

  Si ottiene che W(S) <= 2 W(S*), per cui il rapporto limite dell'algoritmo pricing e' 2.

Cammini disgiunti

Confronto greedy / pricing. Dato un grafo orientato e un valore intero c detto capacita' si vuole considerare ciascuna coppia di nodi come una richiesta di passaggio dal nodo s[i] al nodo t[i] come sorgente / destinazione. Si vogliono trovare i cammini che permettono di soddisfare il maggior numero possibile di richieste di passaggio.

Problemi: percorsi che condividono archi non sono ottimali, e troppi cammini che condividono uno stesso arco portano a disfunzioni nella maggior parte delle applicazioni.

Si consideri il caso in cui c==1, ovvero ogni arco porta solo una richiesta e i cammini devono per forza essere disgiunti.

• Approssimati/Greedy (algoritmi II): L'algoritmo greedy tende a selezionare cammini piu' brevi rispetto a cammini piu' lunghi. Se il grafo e' connesso, allora l'algoritmo seleziona almeno un cammino. (vedi slides)