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:
    1. Se escludere l'elemento i-esimo non preclude la possibilita' di ottenere una
       soluzione, allora si visita il sottoalbero destro
    2. 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*)