From 2a2b5daa7d7f265f2392ca5fa05a38dc08b26c41 Mon Sep 17 00:00:00 2001 From: Kevin Brewer Date: Tue, 4 Sep 2018 01:47:05 -0500 Subject: [PATCH] Simplify dpMaximumSubarray (#189) * Simplify dpMaximumSubarray * change var name from currentMaxSum to currentSum * fix comment with old variable name --- .../maximum-subarray/dpMaximumSubarray.js | 78 ++++++++----------- 1 file changed, 31 insertions(+), 47 deletions(-) diff --git a/src/algorithms/sets/maximum-subarray/dpMaximumSubarray.js b/src/algorithms/sets/maximum-subarray/dpMaximumSubarray.js index 12f919d7..2abfd88d 100644 --- a/src/algorithms/sets/maximum-subarray/dpMaximumSubarray.js +++ b/src/algorithms/sets/maximum-subarray/dpMaximumSubarray.js @@ -6,57 +6,41 @@ * @return {Number[]} */ export default function dpMaximumSubarray(inputArray) { - // Check if all elements of inputArray are negative ones and return the highest - // one in this case. - let allNegative = true; - let highestElementValue = null; - for (let i = 0; i < inputArray.length; i += 1) { - if (inputArray[i] >= 0) { - allNegative = false; - } - - if (highestElementValue === null || highestElementValue < inputArray[i]) { - highestElementValue = inputArray[i]; - } - } - - if (allNegative && highestElementValue !== null) { - return [highestElementValue]; - } - - // Let's assume that there is at list one positive integer exists in array. - // And thus the maximum sum will for sure be grater then 0. Thus we're able - // to always reset max sum to zero. - let maxSum = 0; - - // This array will keep a combination that gave the highest sum. - let maxSubArray = []; - - // Current sum and subarray that will memoize all previous computations. + // We iterate through the inputArray once, using a greedy approach + // to keep track of the maximum sum we've seen so far and the current sum + // + // currentSum gets reset to 0 everytime it drops below 0 + // + // maxSum is set to -Infinity so that if all numbers + // are negative, the highest negative number will constitute + // the maximum subarray + let maxSum = -Infinity; let currentSum = 0; - let currentSubArray = []; - for (let i = 0; i < inputArray.length; i += 1) { - // Let's add current element value to the current sum. - currentSum += inputArray[i]; + // We need to keep track of the starting and ending indices that + // contributed to our maxSum so that we can return the actual subarray + let maxStartIndex = 0; + let maxEndIndex = inputArray.length; + let currentStartIndex = 0; - if (currentSum < 0) { - // If the sum went below zero then reset it and don't add current element to max subarray. - currentSum = 0; - // Reset current subarray. - currentSubArray = []; - } else { - // If current sum stays positive then add current element to current sub array. - currentSubArray.push(inputArray[i]); + inputArray.forEach((num, currentIndex) => { + currentSum += num; - if (currentSum > maxSum) { - // If current sum became greater then max registered sum then update - // max sum and max subarray. - maxSum = currentSum; - maxSubArray = currentSubArray.slice(); - } + // Update maxSum and the corresponding indices + // if we have found a new max + if (maxSum < currentSum) { + maxSum = currentSum; + maxStartIndex = currentStartIndex; + maxEndIndex = currentIndex + 1; } - } - return maxSubArray; + // Reset currentSum and currentStartIndex + // if currentSum drops below 0 + if (currentSum < 0) { + currentSum = 0; + currentStartIndex = currentIndex + 1; + } + }); + + return inputArray.slice(maxStartIndex, maxEndIndex); }