跳转至

3903. 最小稳定下标 I

题目描述

给你一个长度为 n 的整数数组 nums 和一个整数 k。

对于每个下标 i，定义它的 不稳定值 为 max(nums[0..i]) - min(nums[i..n - 1])。

换句话说：

  • max(nums[0..i]) 表示从下标 0 到下标 i 的元素中的 最大值 。
  • min(nums[i..n - 1]) 表示从下标 i 到下标 n - 1 的元素中的 最小值 。

如果某个下标 i 的不稳定值 小于等于 k，则称该下标为 稳定下标 。

返回 最小 的稳定下标。如果不存在这样的下标，则返回 -1。

 

示例 1：

输入： nums = [5,0,1,4], k = 3

输出： 3

解释：

  • 在下标 0 处：[5] 中的最大值是 5，[5, 0, 1, 4] 中的最小值是 0，因此不稳定值为 5 - 0 = 5。
  • 在下标 1 处：[5, 0] 中的最大值是 5，[0, 1, 4] 中的最小值是 0，因此不稳定值为 5 - 0 = 5。
  • 在下标 2 处：[5, 0, 1] 中的最大值是 5，[1, 4] 中的最小值是 1，因此不稳定值为 5 - 1 = 4。
  • 在下标 3 处：[5, 0, 1, 4] 中的最大值是 5，[4] 中的最小值是 4，因此不稳定值为 5 - 4 = 1。
  • 这是第一个不稳定值小于等于 k = 3 的下标，因此答案是 3。

示例 2：

输入： nums = [3,2,1], k = 1

输出： -1

解释：

  • 在下标 0 处，不稳定值为 3 - 1 = 2。
  • 在下标 1 处，不稳定值为 3 - 1 = 2。
  • 在下标 2 处，不稳定值为 3 - 1 = 2。
  • 这些值都不小于等于 k = 1，因此答案是 -1。

示例 3：

输入： nums = [0], k = 0

输出： 0

解释：

在下标 0 处，不稳定值为 0 - 0 = 0，它小于等于 k = 0。因此答案是 0。

 

提示：

  • 1 <= nums.length <= 100
  • 0 <= nums[i] <= 109
  • 0 <= k <= 109

解法

方法一：预处理 + 枚举

我们首先预处理出一个数组 \(\textit{right}\)，其中 \(\textit{right}[i]\) 表示数组 \(nums\) 中从下标 \(i\) 到下标 \(n - 1\) 的元素中的最小值。我们可以从后往前遍历数组 \(nums\) 来计算出 \(\textit{right}\) 数组。

接下来，我们从前往后遍历数组 \(nums\)，维护一个变量 \(\textit{left}\)，表示数组 \(nums\) 中从下标 \(0\) 到下标 \(i\) 的元素中的最大值。对于每个下标 \(i\)，我们计算出不稳定值 \(\textit{left} - \textit{right}[i]\)，如果不稳定值小于等于 \(k\)，则返回下标 \(i\)。如果遍历结束后没有找到满足条件的下标，则返回 \(-1\)。

时间复杂度 \(O(n)\)，空间复杂度 \(O(n)\)。其中 \(n\) 是数组 \(nums\) 的长度。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Solution:
    def firstStableIndex(self, nums: list[int], k: int) -> int:
        n = len(nums)
        right = [nums[-1]] * n
        for i in range(n - 2, -1, -1):
            right[i] = min(right[i + 1], nums[i])
        left = 0
        for i, x in enumerate(nums):
            left = max(left, x)
            if left - right[i] <= k:
                return i
        return -1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public int firstStableIndex(int[] nums, int k) {
        int n = nums.length;
        int[] right = new int[n];
        right[n - 1] = nums[n - 1];

        for (int i = n - 2; i >= 0; i--) {
            right[i] = Math.min(right[i + 1], nums[i]);
        }

        int left = 0;
        for (int i = 0; i < n; i++) {
            left = Math.max(left, nums[i]);
            if (left - right[i] <= k) {
                return i;
            }
        }
        return -1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
public:
    int firstStableIndex(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> right(n);
        right[n - 1] = nums[n - 1];

        for (int i = n - 2; i >= 0; --i) {
            right[i] = min(right[i + 1], nums[i]);
        }

        int left = 0;
        for (int i = 0; i < n; ++i) {
            left = max(left, nums[i]);
            if (left - right[i] <= k) {
                return i;
            }
        }
        return -1;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
func firstStableIndex(nums []int, k int) int {
    n := len(nums)
    right := make([]int, n)
    right[n-1] = nums[n-1]

    for i := n - 2; i >= 0; i-- {
        right[i] = min(right[i+1], nums[i])
    }

    left := 0
    for i, x := range nums {
        left = max(left, x)
        if left-right[i] <= k {
            return i
        }
    }
    return -1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
function firstStableIndex(nums: number[], k: number): number {
    const n = nums.length;
    const right = new Array<number>(n);
    right[n - 1] = nums[n - 1];

    for (let i = n - 2; i >= 0; i--) {
        right[i] = Math.min(right[i + 1], nums[i]);
    }

    let left = 0;
    for (let i = 0; i < n; i++) {
        left = Math.max(left, nums[i]);
        if (left - right[i] <= k) {
            return i;
        }
    }
    return -1;
}

评论