95 lines
2.7 KiB
Markdown
95 lines
2.7 KiB
Markdown
# The slow solution
|
|
|
|
We can calculate all possible subsums.
|
|
|
|
The simplest way is to take every element and calculate sums of all subarrays starting from it.
|
|
|
|
For instance, for `[-1, 2, 3, -9, 11]`:
|
|
|
|
```js no-beautify
|
|
// 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
|
|
-11
|
|
```
|
|
|
|
The code is actually a nested loop: the external loop over array elements, and the internal counts subsums starting with the current element.
|
|
|
|
```js run
|
|
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]) ); // 100
|
|
```
|
|
|
|
The solution has a time complexety of [O(n<sup>2</sup>)](https://en.wikipedia.org/wiki/Big_O_notation). In other words, if we increase the array size 2 times, the algorithm will work 4 times longer.
|
|
|
|
For big arrays (1000, 10000 or more items) such algorithms can lead to a seroius sluggishness.
|
|
|
|
# Fast solution
|
|
|
|
Let's walk the array and keep the current partial sum of elements in the variable `s`. If `s` becomes negative at some point, then assign `s=0`. The maximum of all such `s` will be the answer.
|
|
|
|
If the description is too vague, please see the code, it's short enough:
|
|
|
|
```js run
|
|
function getMaxSubSum(arr) {
|
|
let maxSum = 0;
|
|
let partialSum = 0;
|
|
|
|
for (let item of arr; i++) { // 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]) ); // 0
|
|
```
|
|
|
|
The algorithm requires exactly 1 array pass, so the time complexity is O(n).
|
|
|
|
You can find more detail information about the algorithm here: [Maximum subarray problem](http://en.wikipedia.org/wiki/Maximum_subarray_problem). If it's still not obvious why that works, then please trace the algorithm on the examples above, see how it works, that's better than any words.
|
|
|