Algoritmica

Algoritmi – Rimuovere i duplicati da un lista

Andrea Angella — Tue, 07 Sep 2010 01:50:44 GMT

Problema:

Considerare una semplice classe che implementa una SingleLinkedList non ordinata di interi. Realizzare un metodo per rimuovere tutti i duplicati dalla lista.

Input:

Niente

Output:

Niente.
Internamente gli elementi duplicati saranno rimossi dalla lista.

Esempio:

Lista iniziale:
1, 1, 1, 1, 3, 4, 5, 3, 5, 1, 2, 1, 2, 3, 4 ,1 , 2, 3, 5, 1, 2, 5, 6, 7, 2, 8, 2, 9, 9

Lista finale:
1, 3, 4, 5, 2, 6, 7, 8, 9

La struttura dati

Il mio ragionamento:

Prendo il valore dell’elemento di testa. Scorro tutti gli elementi successivi. Se uno degli elementi successivi e’ duplicato aggiorno i puntatori in modo da bypassarlo. Ripeto il procedimento per l’elemento successivo della lista e cosi’ via.

La complessita’ di questo algoritmo e’ O(N^2).

La mia soluzione:

public void RemoveDuplicates()
 {
     if (head == null) return;
 
     Node p = head;
     while (p != null)
     {
         int value = p.Value;
 
         Node q = p;
         while (q.Next != null)
             if (q.Next.Value == value) q.Next = q.Next.Next;
             else q = q.Next;
 
         p = p.Next;
     }
 }

Una soluzione piu’ efficiente

Se si utilizza un dizionario e’ possibile portare la complessita’ dell’algoritmo a poco piu’ di O(N)

public void RemoveDuplicates_Using_Dictionary()
 {
     if (head == null) return;
 
     var d = new Dictionary<int, bool>();
     d[head.Value] = true;
 
     Node node = head;
     while (node.Next != null)
     {
         int value = node.Next.Value;
 
         if (d.ContainsKey(value))
         {
             node.Next = node.Next.Next;
         }
         else
         {
             d[value] = true;
             node = node.Next;
         }
     }
 }

Algoritmi – Determinare il sottoinsieme più grande di intervalli mutuamente non sovrapposti

Andrea Angella — Sun, 05 Sep 2010 04:33:31 GMT

Problema:

Dato un insieme I di n intervalli [a, b] con a e b interi determinare il sottoinsieme piu’ grande di intervalli mutuamente non sovrapposti che possono essere selezionati da I.

Input:

Due vettori di n interi che rappresentano l’insieme I.

a = { a0, a1, … }
b = { b0, b1, … }

Ogni intervallo e’ identificato da un numero intero k.

L’intervallo generico k e’ rappresentato dagli estremi a[k] e b[k].

Output:

Una lista di interi ordinata (List<int>) che contiene gli identificatori degli intervalli che fanno parte del sottoinsieme di interesse.

Esempio:

Input:

a = { 0, 7, 15, 2, 8, 15, 18, 3, 10, 12, 15, 1, 4, 8, 20 };
b = { 4, 12, 18, 6, 14, 17, 20, 9, 11, 14, 19, 5, 7, 20, 22 };

Output:

{ 0, 5, 6, 8, 9, 12, 14 } oppure
{ 0, 2, 6, 8, 9, 12, 14 }

Di seguito i diagrammi che rappresentano i due risultati validi (evidenziati in giallo):

Il mio ragionamento:

Per ciascun intervallo determino gli intervalli che si sovrappongono. Ordino quindi gli intervalli in base al numero di sovrapposizioni. Partendo dagli intervalli con il minor numero di sovrapposizioni inizio ad aggiungerli al risultato, scartando a mano a mano gli intervalli sovrapposti.

La complessita’ di questa soluzione e’ O(N^2).

Non sono in grado di provare se questa soluzione e’ corretta per qualsiasi istanza del problema.

La mia soluzione:

class Interval
 {
     public int ID { get; set; }
     public List<int> Overlaps { get; set; }
     public bool IsCandidate { get; set; }
 
     public Interval(int interval)
     {
         ID = interval;
         Overlaps = new List<int>();
         IsCandidate = true;
     }
 }
 
 static List<int> GetBiggestNonOverlappedIntervalSubset(int[] a, int[] b)
 {
     if (a == null) throw new ArgumentNullException("a");
     if (b == null) throw new ArgumentNullException("b");
     if (a.Length != b.Length) throw new ArgumentException("a and b must have the same length");
 
     int n = a.Length;
     List<int> results = new List<int>();
 
     Interval[] intervals = new Interval[n];
     for (int i = 0; i < n; ++i) 
         intervals[i] = new Interval(i);
 
     for (int i = 0; i < n; ++i)
         for (int j = i + 1; j < n; ++j)
             if (a[i] < b[j] && a[j] < b[i])
             {
                 intervals[i].Overlaps.Add(j);
                 intervals[j].Overlaps.Add(i);
             }
 
     Array.Sort<Interval>(intervals, (info1, info2) => info1.Overlaps.Count - info2.Overlaps.Count);
 
     for (int i = 0; i < n; ++i)
         if (intervals[i].IsCandidate)
         {
             int newInterval = intervals[i].ID;
             results.Add(newInterval);
 
             for (int j = i + 1; j < n; ++j)
                 if (intervals[j].Overlaps.Contains(newInterval))
                     intervals[j].IsCandidate = false;                    
         }
 
     results.Sort();
 
     return results;
 }

I miei test:

Un problema piu’ complesso come questo richiede la presenza di qualche test automatico.

[TestMethod()]
 public void GetBiggestNonOverlappedIntervalSubsetTest_DisjointedIntervals()
 {
     int[] a = new int[] { 0, 6, 10 };
     int[] b = new int[] { 4, 8, 12 };
 
     var expected = new List<int> { 0, 1, 2 };
 
     List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
 
     Assert.IsTrue(actual.Count == 3);
     CollectionAssert.AreEquivalent(expected, actual);
 }
 
 [TestMethod()]
 public void GetBiggestNonOverlappedIntervalSubsetTest1()
 {
     int[] a = new int[] { 0, 7, 15, 2, 8, 15, 18, 3, 10, 12, 15, 1, 4, 8, 20 };
     int[] b = new int[] { 4, 12, 18, 6, 14, 17, 20, 9, 11, 14, 19, 5, 7, 20, 22 };
 
     var expected1 = new List<int> { 0, 5, 6, 8, 9, 12, 14 };
     var expected2 = new List<int> { 0, 2, 6, 8, 9, 12, 14 };
 
     List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
 
     Assert.IsTrue(actual.Count == 7);
     Assert.IsTrue(ListEquals(actual, expected1) || ListEquals(actual, expected2));
 }
 
 [TestMethod()]
 public void GetBiggestNonOverlappedIntervalSubsetTest2()
 {
     int[] a = new int[] { 0, 1, 2, 3, 4 };
     int[] b = new int[] { 2, 3, 4, 5, 6 };
 
     var expected = new List<int> { 0, 2, 4 };
 
     List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
 
     Assert.IsTrue(actual.Count == 3);
     CollectionAssert.AreEquivalent(expected, actual);
 }
 
 private bool ListEquals(List<int> a, List<int> b)
 {
     if (a.Count != b.Count) return false;
 
     int n = a.Count;
 
     for (int i = 0; i < n; ++i)
         if (a[i] != b[i])
             return false;
 
     return true;            
 }

Voi come lo avreste implementato? Idee?

Pensate che la mia soluzione sia corretta?
Se no, potete fornire un contro esempio che porta ad un risultato scorretto?

Algoritmi – Dire se due parole sono anagrammi

Andrea Angella — Sat, 04 Sep 2010 17:48:32 GMT

Problema:

Date due parole (stringhe) dire se sono anagrammi.

Input:

Due stringhe che rappresentano due parole (spazi esclusi)

Output:

Un booleano

Esempio:

Input: “nave” e “vena”
Output: true

Input: “nave” e “neve”
Output: false

Il mio ragionamento:

Se le due parole hanno un numero di caratteri differenti non possono essere anagrammi.

Calcolo il numero di occorrenze di ciascun carattere nella prima parola.

Per ogni carattere della seconda parola verifico se ce n’e’ uno corrispondente nella prima decrementando il contatore corrispondente. Se uno dei contatori e’ pari a zero prima del decremento significa che non c’e’ un numero sufficiente di caratteri e quindi ritorno false.

Nota: contare se un qualche contatore e’ rimasto maggiore di zero dopo l’ultimo foreach non e’ necessario perche’ sappiamo che le due parole hanno la stessa lunghezza. Se il numero di occorrenze di una certa lettera nella prima parola e’ maggiore rispetto al numero di occorrenze nella seconda parola, allora esistera’ sempre la situazione opposta.

La mia soluzione O(N):

static bool IsAnagram(string s1, string s2)
 {
     if (s1 == null) throw new ArgumentNullException("s1");
     if (s2 == null) throw new ArgumentNullException("s2");
     
     if (s1.Length != s2.Length) 
         return false;
 
     uint[] counters = new uint[char.MaxValue + 1];
 
     foreach(char c in s1) 
         ++counters[c];
 
     foreach(char c in s2)
         if( counters[c]-- == 0) return false;
 
     return true;
 }

Mia seconda soluzione utilizzando l’idea dell’ordinamento O(N):

static class StringExtensions
 {
     public static char[] ToOrderedCharArray(this string s)
     {
         if (s == null) throw new ArgumentNullException("s");
 
         char[] chars = new char[s.Length];
         
         uint[] counters = new uint[char.MaxValue + 1];
         foreach (char c in s) ++counters[c];
 
         int p = 0;
 
         for(int c = 0; c < counters.Length; ++c)
             for (int i = 0; i < counters[c]; ++i)
                 chars[p++] = (char)c;
 
         return chars;
     }
 }
 
 static class ArrayExtensions
 {
     public static bool IsEquivalent<T>(this T[] array1, T[] array2)
     {
         if (array2 == null) throw new ArgumentNullException("vc2");
         if (array1.Length != array2.Length) return false;
         
         int n = array1.Length;
 
         for(int i = 0; i < n; i++)
             if( !array1[i].Equals(array2[i]) )
                 return false;
 
         return true;
     }
 }

static bool IsAnagram_Sorting_Version(string s1, string s2)
 {
     if (s1 == null) throw new ArgumentNullException("s1");
     if (s2 == null) throw new ArgumentNullException("s2");
 
     if (s1.Length != s2.Length) return false;
 
     char[] vc1 = s1.ToOrderedCharArray();
     char[] vc2 = s2.ToOrderedCharArray();
 
     return vc1.IsEquivalent(vc2);
 }

La leggibilita’ di questa soluzione e’ indiscutibile.

La complessita’ e’ ancora O(N) anche se la performance e’ piu’ bassa rispetto alla soluzione precedente.
Inoltre questa soluzione richiede un uso maggiore della memoria per memorizzare gli array ordinati di caratteri.

Personalmente ritengo la versione precedente preferibile.

Algoritmi – Rimuovere i caratteri duplicati in una stringa

Andrea Angella — Sat, 04 Sep 2010 16:16:08 GMT

Problema:

Rimuovere tutti i caratteri duplicati da una stringa. Gli spazi devono essere preservati.

Vincoli:

Se si utilizza C++ modificare direttamente il parametro di input senza utilizzare buffer aggiuntivi.

Se si utilizza C# ritornare una nuova stringa. In quanto le stringhe sono immutabili, e’ consentito l’utilizzo del metodo ToCharArray() per attenere un buffer su cui lavorare.

Input:

Una stringa

Output:

Una stringa

Esempio:

Input: “Microsoft .Net Framework”

Output: “Microsft .Ne Famwk”

Il mio ragionamento:

Itero il buffer della stringa e costruisco all’inizio di esso la stringa risultato. Uno speciale indice mi indichera’ la posizione dell’ultimo elemento nella stringa risultato. Un nuovo carattere sara’ aggiunto solo dopo la verifica che non sia un duplicato, mentre uno spazio sara’ sempre aggiunto.

La complessita’ dell’algoritmo e’ O(N^2) dove N e’ il numero di elementi distinti presenti nella stringa.

Una soluzione piu’ efficiente consiste nell’utilizzare un vettore di booleani di appoggio per ricordarsi quali caratteri sono gia’ stati visitati. Questo evita un ciclo innestato rendendo la soluzione di complessita’ lineare.

La mia soluzione in C++:

void RemoveDuplicates(char* s)
 {
     if (s == NULL) throw exception("s cannot be null");
 
     char c;
     int i = 0;
     int end = 0;
 
     while(c = s[i])
     {
         bool duplicate = false;
 
         if (!isspace(c))
         {
             for(int j = 0; j < i; ++j)
                 if (s[j] == c)
                 {
                     duplicate = true;
                     break;
                 }
         }
 
         if (!duplicate) s[end++] = c;
 
         ++i;
     }
 
     s[end] = 0;
 }

La mia soluzione in C#:

public static class StringExtension
 {
     public static string RemoveDuplicates(this string s)
     {
         if (s == null) throw new ArgumentNullException("s");
         if (s.Length < 2) return s;
 
         char[] vc = s.ToCharArray();
         int len = s.Length;
         int end = 0;
 
         for (int i = 0; i < len; ++i)
         {
             char c = vc[i];
             bool duplicate = false;
 
             if (!char.IsWhiteSpace(c))
                 for (int j = 0; j < end; j++)
                     if (c == vc[j])
                     {
                         duplicate = true;
                         break;
                     }
 
             if (!duplicate)
                 vc[end++] = c;
         }
 
         return new string(vc, 0, end);
     }
 }

Soluzione in C# piu’ efficiente

public static string RemoveDuplicates(this string s)
 {
     if (s == null) throw new ArgumentNullException("s");
     if (s.Length < 2) return s;
 
     char[] vc = new char[s.Length];
     bool[] visited = new bool[char.MaxValue + 1];
     int end = 0;
 
     foreach (char c in s)
     {
         if (!visited[c] || char.IsWhiteSpace(c))
         {
             vc[end++] = c;
             visited[c] = true;
         }
     }
 
     return new string(vc, 0, end);                        
 }

Algoritmi – Invertire una stringa

Andrea Angella — Fri, 03 Sep 2010 01:39:58 GMT

Problema:

Data una stringa, calcolare e ritornare una nuova stringa con gli stessi caratteri ma in ordine inverso.

Esempio: ABCDE
Risultato: EDCBA

Input:

Una stringa.

Output:

La stringa di input con i caratteri in ordine inverso.

Il mio ragionamento:

Costruisco un vettore di caratteri lungo quanto la stringa e lo riempio con un semplice ciclo for.

La mia soluzione:

public static string Reverse(string s)
 {
     if (s == null) throw new ArgumentNullException("s");
     if (s.Length < 2) return s;
 
     char[] vc = new char[s.Length];
 
     int n = s.Length - 1;
 
     for (int i = 0; i <= n; ++i)
         vc[i] = s[n - i];
 
     return new String(vc);
 }

Algoritmi – Determinare dal testo di una rivista se e’ possibile creare una ransom note

Andrea Angella — Thu, 02 Sep 2010 01:51:12 GMT

Problema 1:

Fino ad ora non sapevo cosa fosse una ransom note.
Praticamente si tratta di un testo realizzato utilizzando ritagli da una rivista.

Dato il testo di una ransom note e il testo della rivista, dire se e’ possibile realizzare la ransom note.

Problema 2:

Risolvere lo stesso problema ma ritagliando parole invece che singoli caratteri.

Input:

Testo della ransom note che si vuole creare (stringa).
Testo della rivista da cui si vuole ritagliare (stringa).

Output:

True se e’ possibile realizzare la ransom note, False altrimenti.

Il mio ragionamento:

Scansiono due volte i testi e costruisco due vettori che conteggiano il numero di occorrenze di ciasun carattere. Fatto questo controllo che ci sia sempre un numero sufficiente di lettere per costruire la ransom note confrontando uno ad uno gli elementi corrispondenti di questi due array.

Per quanto riguarda il problema 2 invece di utilizzare due vettori, utilizzo due tabelle hash. La logica e’ sostanzialmente la stessa.

Le mie soluzioni:

public static bool IsCharacterRansomNotePossible(string noteText, string magazineText)
 {
     if (String.IsNullOrEmpty(noteText) || String.IsNullOrEmpty(magazineText))
         throw new ArgumentException("noteText and/or magazineText cannot be null or empty");
 
     const int N = Char.MaxValue + 1;
     
     uint[] noteCount = new uint[N];
     uint[] magazineCount = new uint[N];
 
     foreach (char c in noteText) ++noteCount[c];            
     foreach (char c in magazineText) ++magazineCount[c];
 
     for (int i = 0; i < N; ++i)
         if (noteCount[i] > magazineCount[i])
             if(!char.IsWhiteSpace((char)i))
                 return false;
 
     return true;
 }
 
 public static bool IsWordRansomNotePossible(string noteText, string magazineText)
 {
     if (String.IsNullOrEmpty(noteText) || String.IsNullOrEmpty(magazineText))
         throw new ArgumentException("noteText and/or magazineText cannot be null or empty");
 
     var noteCount = new Dictionary<string, int>();
     var magazineCount = new Dictionary<string, int>();
 
     var noteWords = noteText.Split();
     var magazineWords = magazineText.Split();
 
     foreach (string s in noteWords)
         if (noteCount.ContainsKey(s)) ++noteCount[s];
         else noteCount[s] = 1;
 
     foreach (string s in magazineWords)
         if (magazineCount.ContainsKey(s)) ++magazineCount[s];
         else magazineCount[s] = 1;
 
     foreach (string word in noteCount.Keys)
         if (!magazineCount.ContainsKey(word) || noteCount[word] > magazineCount[word])
             return false;
 
     return true;
 }

Qualunque commento e’ ben accetto. Il codice non e’ stato testato rigorosamente.

Soluzione di Ludovico Van:

public static bool IsCharRansomNotePossible(string note, string source)
 {
     note = note == null ? string.Empty : note.Trim();
     source = source == null ? string.Empty : source.Trim();
 
     if (note.Length == 0)
         return true;
 
     int[] charCounts = new int[1 + char.MaxValue];
 
     int charSetCount = 0;
 
     foreach (char ch in note)
         if (!char.IsWhiteSpace(ch))
             if (charCounts[ch]++ == 0)
                 ++charSetCount;
 
     foreach (char ch in source)
         if (charCounts[ch] != 0)
             if (--charCounts[ch] == 0)
                 if (--charSetCount == 0)
                     return true;
 
     return false;
 }

DSA and BCL - Unordered List Stress Test

Andrea Angella — Sun, 28 Sep 2008 01:34:58 GMT

Come tutti sapete Granville Barnett e Luca del Tongo stanno lavorando alla realizzazione di una libreria open-source di strutture dati e algoritmi (DSA) con lo scopo di arricchire le funzionalità offerte dalla libreria di base del framework 3.5 (BCL). Sono molto interessato all'evoluzione del progetto, per questo ho scaricato l'attuale release 0.6 ed ho iniziato a studiarla attentamente (segnalo anche la presenza di un eBook scritto dagli stessi autori per meglio comprendere gli algoritmi implementati). Sono rimasto piacevolmente colpito dalla pulizia e chiarezza del codice di implementazione e soprattutto dallo sforzo impiegato a mantenere intuitivo l'utilizzo della libreria (molti metodi e proprietà infatti hanno nomi analoghi a quelli implementati da Microsoft ma non è certo solo in questo lo sforzo).

Come sottolineano gli stessi autori l'aspetto più critico quando le performance sono importanti è saper scegliere le strutture dati e gli algoritmi migliori nel particolare contesto applicativo. In questo post voglio mostrarvi i risultati che ho ottenuto dalla mia analisi delle strutture dati di tipo lista non ordinata presenti nella BCL e nella libreria DSA.

Le strutture dati presenti nella BCL che ho coinvolto sono:

List
LinkedList
Stack
Queue

Le strutture dati presenti nella libreria DSA che ho coinvolto sono:

SinglyLinkedList
DoublyLinkedList
Deque

Prima di mostrare i risultati ottenuti è bene sottolineare quando è opportuno scegliere il tipo di dati lista non ordinata all'interno di una applicazione. Generalmente si sceglie una lista non ordinata quando si desiderano effettuare le seguenti operazioni:

Inserimento di elementi (senza un ordinamento particolare)
Rimozione di elementi
Enumerazione degli elementi

Ho voluto quindi testare la velocità di esecuzione dei seguenti metodi:

AddLast() : inserimento di un elemento in coda alla lista
AddFirst() : inserimento di un elemento in testa alla lista
RemoveLast() : rimozione dell'elemento in coda alla lista
RemoveFirst() : rimozione dell'elemento in testa alla lista
Remove() : rimozione di un elemento con un certo valore

Di seguito riporto i risultati ottenuti considerando che ogni metodo è stato eseguito 100 Mila volte:

Considerazioni su AddLast():

List è sicuramente la struttura dati più veloce; Il motivo è certamente dovuto al fatto che la sua implementazione interna sfrutta un vettore a crescita dinamica; Questo vettore di appoggio viene rilocato con dimensioni doppie nel momento in cui non è più disponibile spazio al suo interno; Anche Stack e Queue utilizzano al loro interno un meccanismo analogo.
SinglyLinkedList e DoublyLinkedList hanno più o meno prestazioni analoghe fra loro e sono migliori della LinkedList del framework; E' importante precisare che la classe LinkedList del framework è implementata come una coda doppia, allo stesso modo di DoublyLinkedList, però in ogni nodo viene memorizzato anche un riferimento alla lista. L'aggiornamento di questo valore per ogni nodo è probabilmente la causa di tale perdita di performance. Qualcuno sa perchè hanno messo questo riferimento in ogni nodo ?
Deque infine è semplicemente un Facade sulla classe DoublyLinkedList. Mi sembra molto strano che le sue prestazioni siano leggermente migliori a DoublyLinkedList considerando il fatto che al suo interno la classe Deque è costretta ad aggiornare il valore di un altro contatore.

Considerazioni su AddFirst():

Sicuramente nel caso in cui si devono fare frequentemente operazioni di questo tipo la scelta migliore risiede in SinglyLinkedList, DoublyLinkedList o Deque.
LinkedList del framework (per il motivo detto prima) ha prestazioni inferiori
List è inefficiente negli inserimenti in testa (e in generale in quelli interni) proprio perchè ciascuna operazione forza uno spostamento di tutti gli elementi successivi

Considerazioni su RemoveLast():

SinglyLinkedList è inefficiente per costruzione. Infatti la monodirezionalità obbliga a scorrere tutta la lista per rimuovere l'ultimo elemento.

Considerazioni su RemoveFirst():

SinglyLinkedList e DoublyLinkedList hanno più o meno prestazioni analoghe sempre migliori della controparte LinkedList del framework.

Considerazioni su Remove():

List per questo tipo di operazione è efficiente proprio perchè sfrutta la memorizzazione tramite array.
Le altre implementazioni infatti richiedono lo scorrimento dell'intera lista ad ogni operazione.

In generale mi sento di tirare queste conclusioni:

Utilizzare Stack quando si ha bisogno di una struttura dati di tipo LIFO
Utilizzare Queue quando si ha bisogno di una struttura dati di tipo FIFO
Utilizzare SinglyLinkedList se si preferisce una struttura dati Queue implementata tramite coda. Le prestazioni sono di poco inferiori a Queue ma in caso di grossi elementi può portare ad una maggiore efficienza in termini di memoria occupata (si consideri il costo di raddoppiare il vettore nell'implementazione di Queue). Probabilmente questa mia considerazione andrebbe in qualche modo provata, sicuramente ci sarà un motivo per cui è stata rimossa l'implementazione di Queue nelle ultime release di DSA (Forse per non creare ulteriore confusione).
SinglyLinkedList in generale conviene usarla quando si ha necessità di scorrere gli elementi in una sola direzione.
DoublyLinkedList si deve utilizzare quando si ha necessità di scorrere gli elementi in entrambe le direzioni.
A mio parere Deque non ha molto senso di esistere perchè le funzionalità offerte sono tutte ottenibili sfruttando una DoublyLinkedList. In pratica utilizzare direttamente DoublyLinkedList dovrebbe anche essere più efficiente (anche se i dati non sembrano dimostrarlo).
LinkedList del framework sembra uscire perdente da questa mia analisi. Bisogna capire perchè ha senso inserire il riferimento alla lista in ciasun nodo !
List è senz'altro la soluzione migliore quando si devono inserire tanti elementi uno in coda all'altro, effettuare delle rimozioni per valore e quindi delle enumerazioni sugli elementi

L'importanza di realizzare algoritmi polinomiali

Andrea Angella — Sat, 12 Jul 2008 01:52:46 GMT

Tutti noi sappiamo quanto sia importante in alcune occasioni trovare un algoritmo polinomiale per risolvere un problema (meglio ancora se lineare o logaritmico). Vorrei sottolineare con un taglio matematico quanta rilevanza può avere questa semplice constatazione.

Supponiamo di avere tre algoritmi che risolvono un medesimo problema. Il primo algoritmo ha complessità esponenziale, il secondo ha complessità quadratica e il terzo è lineare. La funzione Ti(n) indica il tempo richiesto dall'algoritmo i-esimo per trovare la soluzione di un problema di dimensione n (in poche parole la complessità dell'algoritmo). Abbiamo quindi:

T1( n ) = 2 ^ n

T2( n ) = n ^ 2

T3( n ) = n

Ci poniamo adesso la seguente domanda: quanti dati ciascuno degli algoritmi precedenti è in grado di elaborare in t unità di tempo ?

La risposta è molto semplice e la soluzione consiste banalmente nel determinare le funzioni inverse a quelle prima elencate.

N1 ( t ) = Log2 ( t )

N2 ( t ) = Sqrt( t )

N3 ( t ) = t

Supponendo di eseguire gli stessi algoritmi su una macchina k volte più veloce la risposta alla precedente domanda sarà il valore delle funzioni Ni(t) calcolate in k * t cioè:

N1 ( k * t ) = Log2 ( k * t ) = Log2 ( k ) + Log2 ( t )

N2 ( k * t ) = Sqrt ( k * t ) = Sqrt ( k ) * Sqrt ( t )

N3 ( k * t ) = k * t

Da ciò risulta molto più evidente la gravità di realizzare algoritmi esponenziali. Nel caso di algoritmi polinomiali il guadagno in termini di quantità di dati trattabili nello stesso tempo è di tipo moltiplicativo. Nel caso di algoritmi esponenziali invece il guadagno è solo di tipo addittivo !!!

In parole più chiare se per assurdo potessimo avere un processore 10000 volte più veloce di quelli attuali, per esempio un processore da 20 Tera Herz ( 10000 volte 2 Giga Hz ) il nostro algoritmo a parità di tempo saprebbe trattare solamente Log2( 10000 ) = 13 dati in più. Il guadagno in termini di scalabilità sui dati è praticamente nullo !!!

Intel come sappiamo ha cambiato rotta nello sviluppo dei suoi processori nella direzione di integrare più core insieme permettendo di fatto un parallelismo reale di esecuzione delle istruzioni. La vera sfida come più volte ha sottolineato Raf ai Community Days 2008 sarà riuscire a scrivere software che sfrutti veramente le nuove architetture multicore. Una sfida sicuramente entusiasmante.

Un problema giocattolo ma particolarmente interessante è il famoso problema della SOTTOSEQUENZA DI SOMMA MASSIMA.

Il problema è il seguente: dato un vettore di numeri interi positivi e negativi determinare la sottosequenza la cui somma è massima.

Diverse sono le possibili soluzioni a questo problema. Due soluzioni immediate ma inefficienti hanno rispettivamente complessità cubica e quadratica. Sfruttando due semplici ma interessanti proprietà è possibile rendere lineare l'algoritmo con indubbi vantaggi sulla velocità di esecuzione e soprattutto sulla scalabilità.

Una semplice applicazione console che realizza e misura le velocità di questi algoritmi la potete trovare nel mio laboratorio online: scarica sottosequenza di somma massima