力扣 2444. 统计定界子数组的数目

题目来源:https://leetcode.cn/problems/count-subarrays-with-fixed-bounds/

大致题意:
给一个数组和两个数,这两个数分别表示子数组的最大值与最小值

求给定数组中最值为给定值的子数组的个数

思路

首先考虑,假设在数组中给定最值的索引为 x 和 y,那么如何确定以 x 和 y 处元素为最值的子数组个数?

  1. 确定左右侧不以 x 和 y 出元素为最值的边界为 l 和 r
  2. 那么以 x 和 y 处元素为最值的子数组个数为 (min(x, y) - l) * (max(i, j) - r)

题目规定了数组长度为 105,如果每次枚举到两个最值,再向两侧枚举边界的时间复杂度会达到 O(n2)

其实不需要每次都枚举边界,因为子数组连续的特性,后一个出现的以 x 和 y 处元素为最值的子数组左边界一定大于前一个的左边界,不需要进行重复的判断

具体解题时,在遍历过程中可以通过三个标志位:

  • border 表示最近出现的大于给定最大值或者小于给定最小值的元素的索引,其对应满足条件的子数组左边界
  • min 表示最近出现的最小值的索引
  • max 表示最近出现的最大值的索引

那么在遍历时,如果已经确定左边界,可以在更新右边界的过程中统计以 x 和 y 处元素为最值的子数组个数,具体方法为

  • min(min, max) - border
  • 即在确定子数组的左边界后,在更新右边界的同时,更新对应左边界子数组的个数
  • 上述计算可能出现负值,即以当前数结尾的子数组不以 x 和 y 处元素为最值,此时不更新子数组个数即可

具体看代码:

	public long countSubarrays(int[] nums, int minK, int maxK) {
        int n = nums.length;
        long ans = 0;
        // 初始化三个标志位
        int min = -1;
        int max = -1;
        int border = -1;
        for (int i = 0; i < n; i++) {
        	// 更新标志位
            if (nums[i] < minK || nums[i] > maxK) {
                border = i;
            }
            if (nums[i] == minK) {
                min = i;
            }
            if (nums[i] == maxK) {
                max = i;
            }
            // 更新满足条件子数组的个数
            // 这里使用max(0, 以当前数结尾的满足条件子数组个数)来避免负数问题
            ans += Math.max(0, Math.min(min, max) - border);
        }
        return ans;
    }
### LeetCode 第 315 题:计算右侧小于当前元素的个数 LeetCode 第 315 题的目标是,给定一个整数数组 `nums`,返回一个新的计数数组 `count`,其中 `count[i]` 表示在 `nums[i]` 右侧比它小的元素的数目。这个问题可以通过多种方法解决,例如归并排序、二叉索引树(Fenwick Tree)或线段树等。 #### 使用归并排序的方法实现 这种方法的核心思想是在归并排序的过程中记录每个元素右侧比它小的元素数量。归并排序中的合并步骤可以帮助我们高效地统计这些信息。 以下是使用归并排序的 Java 解法: ```java import java.util.*; public class Solution { private int[] count; public List<Integer> countSmaller(int[] nums) { int n = nums.length; count = new int[n]; int[] indices = new int[n]; for (int i = 0; i < n; i++) { indices[i] = i; } mergeSort(nums, indices, 0, n - 1); List<Integer> result = new ArrayList<>(); for (int c : count) { result.add(c); } return result; } private void mergeSort(int[] nums, int[] indices, int left, int right) { if (right - left <= 1) { return; } int mid = (left + right) / 2; mergeSort(nums, indices, left, mid); mergeSort(nums, indices, mid, right); merge(nums, indices, left, mid, right); } private void merge(int[] nums, int[] indices, int left, int mid, int right) { int[] temp = new int[right - left + 1]; int i = left, j = mid, k = 0; int[] smallerCount = new int[right - left + 1]; while (i < mid && j <= right) { if (nums[indices[i]] <= nums[indices[j]]) { // 记录右侧比当前元素小的数目 smallerCount[k] = j - mid; temp[k++] = indices[i++]; } else { temp[k++] = indices[j++]; } } while (i < mid) { smallerCount[k] = j - mid; temp[k++] = indices[i++]; } while (j <= right) { temp[k++] = indices[j++]; } // 更新 count 数组 for (int p = 0; p < temp.length; p++) { nums[temp[p]] += smallerCount[p]; // 累加右侧较小元素的数量 count[temp[p]] += nums[temp[p]]; } } } ``` #### 思路说明: - **归并排序**:通过递归将数组分割成最小单元后,在合并过程中统计右侧比当前元素小的数目。 - **索引数组**:为了避免直接修改原始数组,我们使用索引数组来跟踪元素的位置。 - **辅助数组 `smallerCount`**:在合并过程中,利用该数组记录每个元素右侧较小的数目,并最终更新到 `count` 数组中。 #### 时间复杂度分析 - 归并排序的时间复杂度为 $O(n \log n)$,因此此解法可以高效处理大规模输入数据 [^3]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三更鬼

谢谢老板!

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值