从暴力到高效：解密 LeetCode 最大子序和的解题之道

前端

2023-10-26 22:28:41

引言

在算法求解的浩瀚海洋中，"最大子序和"问题犹如一颗璀璨的明珠，引领着我们探索算法的奥秘。LeetCode 上这道经典题目的求解过程，宛如一场智慧与技巧的较量，从暴力求解到高效优化，让我们领略算法思维的进化轨迹。

初探暴力求解

算法的初始阶段，往往从暴力穷举入手，它犹如一场蛮力对决，耗时耗力却不失为一种求解途径。对于最大子序和问题，暴力算法的思路清晰直观：逐一遍历数组中的所有子数组，计算其和值，最终选出和值最大的子数组。

这种朴素的算法虽然简单易懂，但其时间复杂度却高达 O(N^3)，其中 N 为数组的长度。当数组规模庞大时，暴力算法的计算量将呈几何级数增长，难以为继。

分而治之的策略

为了提升求解效率，算法大师们另辟蹊径，采用"分而治之"的策略。这种方法将大问题分解为若干个小问题，逐一求解后再合并结果。

最大子序和问题的分治算法遵循以下步骤：

将原数组一分为二，分别求解左右两部分的最大子序和。
比较左右两部分的最大子序和，以及跨越中点的最大子序和。
取三者中最大的和值作为原数组的最大子序和。

分而治之算法的时间复杂度为 O(N log N)，较暴力算法有了显著的提升，但仍有优化空间。

在线处理的突破

算法优化的下一个阶段，便是"在线处理"的突破。这种方法抛弃了递归的层层嵌套，采用自底向上的方式逐一扫描数组元素，在扫描过程中维护当前的最大子序和。

在线处理算法的核心思想在于：

将当前子序和与上一步的最大子序和进行比较，取较大者作为当前的最大子序和。
如果当前子序和为负，则将其重置为 0。

在线处理算法的时间复杂度仅为 O(N)，实现了算法求解效率的质的飞跃。

代码实践

以下 JavaScript 代码展示了最大子序和问题的三种解法：

// 暴力求解
function maxSubArrayBruteForce(arr) {
  let maxSum = Number.MIN_SAFE_INTEGER;
  for (let i = 0; i < arr.length; i++) {
    for (let j = i; j < arr.length; j++) {
      let sum = 0;
      for (let k = i; k <= j; k++) {
        sum += arr[k];
      }
      maxSum = Math.max(maxSum, sum);
    }
  }
  return maxSum;
}

// 分而治之
function maxSubArrayDivideAndConquer(arr, start, end) {
  if (start === end) {
    return arr[start];
  }

  const mid = Math.floor((start + end) / 2);
  const leftSum = maxSubArrayDivideAndConquer(arr, start, mid);
  const rightSum = maxSubArrayDivideAndConquer(arr, mid + 1, end);

  let maxSum = Math.max(leftSum, rightSum);

  let leftMax = 0;
  let rightMax = 0;
  for (let i = mid; i >= start; i--) {
    leftMax += arr[i];
    maxSum = Math.max(maxSum, leftMax);
  }

  for (let j = mid + 1; j <= end; j++) {
    rightMax += arr[j];
    maxSum = Math.max(maxSum, rightMax);
  }

  return maxSum;
}

// 在线处理
function maxSubArrayKadane(arr) {
  let maxSum = Number.MIN_SAFE_INTEGER;
  let currentSum = 0;
  for (let i = 0; i < arr.length; i++) {
    currentSum = Math.max(currentSum + arr[i], arr[i]);
    maxSum = Math.max(maxSum, currentSum);
  }
  return maxSum;
}