Question

2945. 找到最大非递减数组的长度

English Version

题目描述

给你一个下标从 0 开始的整数数组 nums 。

你可以执行任意次操作。每次操作中，你需要选择一个 子数组 ，并将这个子数组用它所包含元素的 和 替换。比方说，给定数组是 [1,3,5,6] ，你可以选择子数组 [3,5] ，用子数组的和 8 替换掉子数组，然后数组会变为 [1,8,6] 。

请你返回执行任意次操作以后，可以得到的 最长非递减 数组的长度。

子数组 指的是一个数组中一段连续 非空 的元素序列。

 

示例 1：

输入：nums = [5,2,2]
输出：1
解释：这个长度为 3 的数组不是非递减的。
我们有 2 种方案使数组长度为 2 。
第一种，选择子数组 [2,2] ，对数组执行操作后得到 [5,4] 。
第二种，选择子数组 [5,2] ，对数组执行操作后得到 [7,2] 。
这两种方案中，数组最后都不是 非递减 的，所以不是可行的答案。
如果我们选择子数组 [5,2,2] ，并将它替换为 [9] ，数组变成非递减的。
所以答案为 1 。

示例 2：

输入：nums = [1,2,3,4]
输出：4
解释：数组已经是非递减的。所以答案为 4 。

示例 3：

输入：nums = [4,3,2,6]
输出：3
解释：将 [3,2] 替换为 [5] ，得到数组 [4,5,6] ，它是非递减的。
最大可能的答案为 3 。

 

提示：

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

解法

方法一

class Solution:
  def findMaximumLength(self, nums: List[int]) -> int:
    n = len(nums)
    s = list(accumulate(nums, initial=0))
    f = [0] * (n + 1)
    pre = [0] * (n + 2)
    for i in range(1, n + 1):
      pre[i] = max(pre[i], pre[i - 1])
      f[i] = f[pre[i]] + 1
      j = bisect_left(s, s[i] * 2 - s[pre[i]])
      pre[j] = i
    return f[n]

class Solution {
  public int findMaximumLength(int[] nums) {
    int n = nums.length;
    long[] s = new long[n + 1];
    for (int i = 0; i < n; ++i) {
      s[i + 1] = s[i] + nums[i];
    }
    int[] f = new int[n + 1];
    int[] pre = new int[n + 2];
    for (int i = 1; i <= n; ++i) {
      pre[i] = Math.max(pre[i], pre[i - 1]);
      f[i] = f[pre[i]] + 1;
      int j = Arrays.binarySearch(s, s[i] * 2 - s[pre[i]]);
      pre[j < 0 ? -j - 1 : j] = i;
    }
    return f[n];
  }
}

class Solution {
public:
  int findMaximumLength(vector<int>& nums) {
    int n = nums.size();
    int f[n + 1];
    int pre[n + 2];
    long long s[n + 1];
    for (int i = 0; i < n; ++i) {
      s[i + 1] = s[i] + nums[i];
    }
    memset(f, 0, sizeof(f));
    memset(pre, 0, sizeof(pre));
    for (int i = 1; i <= n; ++i) {
      pre[i] = max(pre[i], pre[i - 1]);
      f[i] = f[pre[i]] + 1;
      int j = lower_bound(s, s + n + 1, s[i] * 2 - s[pre[i]]) - s;
      pre[j] = i;
    }
    return f[n];
  }
};

func findMaximumLength(nums []int) int {
  n := len(nums)
  f := make([]int, n+1)
  pre := make([]int, n+2)
  s := make([]int, n+1)
  for i, x := range nums {
    s[i+1] = s[i] + x
  }
  for i := 1; i <= n; i++ {
    pre[i] = max(pre[i], pre[i-1])
    f[i] = f[pre[i]] + 1
    j := sort.SearchInts(s, s[i]*2-s[pre[i]])
    pre[j] = max(pre[j], i)
  }
  return f[n]
}

function findMaximumLength(nums: number[]): number {
  const n = nums.length;
  const f: number[] = Array(n + 1).fill(0);
  const pre: number[] = Array(n + 2).fill(0);
  const s: number[] = Array(n + 1).fill(0);
  for (let i = 1; i <= n; ++i) {
    s[i] = s[i - 1] + nums[i - 1];
  }
  const search = (nums: number[], x: number): number => {
    let [l, r] = [0, nums.length];
    while (l < r) {
      const mid = (l + r) >> 1;
      if (nums[mid] >= x) {
        r = mid;
      } else {
        l = mid + 1;
      }
    }
    return l;
  };
  for (let i = 1; i <= n; ++i) {
    pre[i] = Math.max(pre[i], pre[i - 1]);
    f[i] = f[pre[i]] + 1;
    const j = search(s, s[i] * 2 - s[pre[i]]);
    pre[j] = i;
  }
  return f[n];
}