每日算法-250527

每日算法 - 250527

2364. 统计坏数对的数目

题目

思路与解题过程

核心思想：转换问题 + 哈希表计数

题目定义“坏数对” (i, j) 为满足 i < j 且 j - i != nums[j] - nums[i] 的数对。
直接统计“坏数对”可能比较复杂，我们可以考虑其补集——“好数对”。
“好数对” (i, j) 满足 i < j 且 j - i == nums[j] - nums[i].

对“好数对”的条件进行变形：
j - i == nums[j] - nums[i]
nums[i] - i == nums[j] - j

令 d[x] = nums[x] - x。那么，“好数对”的条件就变成了 i < j 且 d[i] == d[j].

解法：直接统计坏数对

虽然可以通过“总数对 - 好数对”来计算，但我们也可以直接统计“坏数对”。
遍历数组 nums，对于每个元素 nums[i]（及其下标 i）：

1. 计算 key = nums[i] - i.
2. 我们想知道，在 nums[i] 之前（即下标 p < i），有多少个元素 nums[p] 满足 nums[p] - p == key。这些 (p, i) 会构成“好数对”。
3. 设 map 存储了之前遇到的 nums[x] - x 的值及其出现的次数。val = map.getOrDefault(key, 0) 就表示在 nums[i] 之前，有多少个下标 p 使得 nums[p] - p == key.
4. 对于当前的 nums[i], 总共有 i 个可能的配对下标 p（从 0 到 i-1）。
5. 其中，有 val 个下标 p 与当前 i 构成了“好数对”。
6. 因此，与当前 i 构成的“坏数对”的数目就是 i - val。我们将这个数目累加到总结果 ret 中。
7. 然后，更新 map：将 key (即 nums[i] - i) 的计数加 1，map.put(key, val + 1). 这为后续的元素 nums[j] (其中 j > i) 提供了信息。

这种方法在遍历到 nums[i] 时，计算的是所有以 i 为较大下标 j 的坏数对 (p, i) 的数量。

复杂度

• 时间复杂度: $O(N)$, 其中 $N$ 是数组 nums 的长度。我们只需要遍历数组一次。哈希表的插入和查找操作平均时间复杂度为 $O(1)$。
• 空间复杂度: $O(N)$, 最坏情况下，哈希表可能需要存储 $N$ 个不同的 nums[i] - i 的值。

Code

class Solution {public long countBadPairs(int[] nums) {long ret = 0;Map<Integer, Integer> map = new HashMap<>(nums.length);for (int i = 0; i < nums.length; i++) {int key = nums[i] - i;int val = map.getOrDefault(key, 0);ret += (long)i - val; map.put(key, val + 1);}return ret;}
}

---

2874. 有序三元组中的最大值 II

题目

思路与解题过程

核心思想：枚举中间元素 + 前缀最大值 + 后缀最大值

我们要找的是三元组 (i, j, k) 使得 i < j < k，并且 (nums[i] - nums[j]) * nums[k] 的值最大。
题目约束 1 <= nums[x] <= 10^6，所以 nums[k] 始终是正数。
为了使乘积最大，我们需要：

1. nums[k] 尽可能大。
2. nums[i] - nums[j] 尽可能大（且为正）。这意味着 nums[i] 要大，nums[j] 要小。

解法步骤：

1. 枚举中间元素 j:
   我们可以遍历所有可能的 j (从 1 到 n-2，其中 n 是数组长度)。

2. 优化 nums[i] 和 nums[k] 的选择:

   • nums[i] 必须从 nums[0...j-1] 中选取。为了使 nums[i] - nums[j] 最大，nums[i] 应为 nums[0...j-1] 中的最大值。
   • nums[k] 必须从 nums[j+1...n-1] 中选取。为了使整个表达式最大 (因为 nums[k] 是正数)，nums[k] 应为 nums[j+1...n-1] 中的最大值。

3. 预计算/动态计算:

   • 后缀最大值 suffixMax: 我们可以预先计算一个数组 suffixMax，其中 suffixMax[p] 表示 nums[p...n-1] 中的最大值。这样，对于给定的 j，nums[k] 的最佳选择就是 suffixMax[j+1]。
   • 前缀最大值 prevMax: 当我们遍历 j 从左到右时，可以动态维护 nums[0...j-1] 的最大值。
     令 prevMax 为 max(nums[0], nums[1], ..., nums[j-1]).

4. 遍历与更新:

   • 初始化 ret = 0。
   • 初始化 prevMax = nums[0].
   • 遍历 j 从 1 到 n-2:
     • 当前的 prevMax 就是 max(nums[0...j-1]).
     • nums[k] 的最佳选择是 suffixMax[j+1].
     • 如果 prevMax > nums[j] (确保 nums[i] - nums[j] 为正，从而得到正的乘积)，则计算 current_value = (long)(prevMax - nums[j]) * suffixMax[j+1].
     • 更新 ret = Math.max(ret, current_value).
     • 更新 prevMax = Math.max(prevMax, nums[j])，为下一次迭代（当 j 变成 j+1 时）做准备。此时，当前的 nums[j] 将成为前缀的一部分。

注意: 乘积可能超过 int 的范围，所以计算时需要使用 long 类型。

复杂度

• 时间复杂度: $O(N)$.
  • 计算 suffixMax 数组需要 $O(N)$.
  • 主循环遍历 j 需要 $O(N)$.
• 空间复杂度: $O(N)$, 主要用于存储 suffixMax 数组。

Code

class Solution {public long maximumTripletValue(int[] nums) {long ret = 0;int n = nums.length;int[] suffixMax = new int[n];suffixMax[n - 1] = nums[n - 1];for (int i = n - 2; i >= 0; i--) {suffixMax[i] = Math.max(nums[i], suffixMax[i + 1]);}int prevMax = nums[0]; for (int j = 1; j < n - 1; j++) {if (prevMax > nums[j]) {long currentVal = (long)(prevMax - nums[j]) * suffixMax[j + 1];ret = Math.max(ret, currentVal);}prevMax = Math.max(prevMax, nums[j]);}return ret;}
}