Il sub-array massimo
Come input si ha un array di numeri, ad esempio arr = [1, -2, 3, 4, -9, 6].
Il compito è: trovate il sub-array contiguo di arr con la massima somma degli elementi.
Scrivete la funzione getMaxSubSum(arr) che ritorna quella somma.
Ad esempio:
getMaxSubSum([-1, 2, 3, -9]) == 5 //(la somma degli elementi selezionati) getMaxSubSum([2, -1, 2, 3, -9]) == 6 getMaxSubSum([-1, 2, 3, -9, 11]) == 11 getMaxSubSum([-2, -1, 1, 2]) == 3 getMaxSubSum([100, -9, 2, -3, 5]) == 100 getMaxSubSum([1, 2, 3]) == 6 //(include tutti)Se tutti gli elementi sono negativi, non prendiamo nulla (il sotto-array è vuoto), quindi la somma è zero:
getMaxSubSum([-1, -2, -3]) = 0Provate a pensare ad una soluzione rapida: O(n2) o addirittura O(n) se riuscite.
La soluzione più lenta
Possiamo calcolare tutte le somme possibili.
La via più semplice è di prendere ogni elemento e calcolare la somma di tutti i sotto-array possibili.
Ad esempio, per [-1, 2, 3, -9, 11]:
// Starting from -1: -1 -1 + 2 -1 + 2 + 3 -1 + 2 + 3 + (-9) -1 + 2 + 3 + (-9) + 11 // Starting from 2: 2 2 + 3 2 + 3 + (-9) 2 + 3 + (-9) + 11 // Starting from 3: 3 3 + (-9) 3 + (-9) + 11 // Starting from -9 -9 -9 + 11 // Starting from 11 11Il codice è un ciclo annidato: il ciclo esterno processa tutti gli elementi dell’array, quello interno esegue le somme a partire dall’elemento corrente.
function getMaxSubSum(arr) { let maxSum = 0; // if we take no elements, zero will be returned for (let i = 0; i < arr.length; i++) { let sumFixedStart = 0; for (let j = i; j < arr.length; j++) { sumFixedStart += arr[j]; maxSum = Math.max(maxSum, sumFixedStart); } } return maxSum; } alert( getMaxSubSum([-1, 2, 3, -9]) ); // 5 alert( getMaxSubSum([-1, 2, 3, -9, 11]) ); // 11 alert( getMaxSubSum([-2, -1, 1, 2]) ); // 3 alert( getMaxSubSum([1, 2, 3]) ); // 6 alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100La soluzione ha una complessità di O(n2). In altre parole, se l’array fosse 2 volte più grande, l’algoritmo lavorerebbe 4 volte più lentamente.
Per grandi array (1000, 10000 o più elementi) questi algoritmi possono portare ad enormi attese.
Soluzione performante
Iniziamo ad esaminare l’array mantenendo la somma parziale degli elementi nella variabile s. Se s diventa negativa, allora assegniamo s=0. La somma di tutte queste s sarà la risposta.
Se la risposta vi sembra troppo vaga, date un’occhiata al codice:
function getMaxSubSum(arr) { let maxSum = 0; let partialSum = 0; for (let item of arr) { // for each item of arr partialSum += item; // add it to partialSum maxSum = Math.max(maxSum, partialSum); // remember the maximum if (partialSum < 0) partialSum = 0; // zero if negative } return maxSum; } alert( getMaxSubSum([-1, 2, 3, -9]) ); // 5 alert( getMaxSubSum([-1, 2, 3, -9, 11]) ); // 11 alert( getMaxSubSum([-2, -1, 1, 2]) ); // 3 alert( getMaxSubSum([100, -9, 2, -3, 5]) ); // 100 alert( getMaxSubSum([1, 2, 3]) ); // 6 alert( getMaxSubSum([-1, -2, -3]) ); // 0L’algoritmo richiede esattamente uno solo scorrimento dell’array, quindi la complessità è O(n).
Potete trovare maggiori dettagli riguardo l’algoritmo qui: Maximum subarray problem. Se ancora non vi risulta ovvio il funzionamento, esaminate più in dettaglio il codice fornito sopra.