优雅子数组 - 技术栈

一、题目描述

如果一个数组中出现次数最多的元素出现大于等于K次，被称为 k-优雅数组 ，k也可以被称为优雅阈值。

例如，数组1，2，3，1、2，3，1，它是一个3-优雅数组，因为元素1出现次数大于等于3次，

数组 $1, 2, 3, 1, 2$ 就不是一个3-优雅数组，因为其中出现次数最多的元素是1和2，只出现了2次。

给定一个数组A和k，请求出A有多少子数组是k-优雅子数组。

子数组是数组中一个或多个连续元素组成的数组。

例如，数组 $1,2,3,4$ 包含10个子数组，分别是：

$1$ , $1,2$ , $1,2,3$ , $1,2,3,4$ , $2$ , $2,3$ , $2,3,4$ , $3$ , $3, 4$ , $4$ 。

二、输入输出描述

输入描述

第一行：两个数字，以空格隔开，分别表示A数组长度、优雅阈值k
第二行：n个整数，以空格隔开，表示A数组元素

输出描述

一个整数，表示数组 A 中 k - 优雅子数组的总数。

三、示例

|----|-------------------|
| 输入 | 7 3 1 2 3 1 2 3 1 |
| 输出 | 1 |
| 说明 | |

|----|-------------------|
| 输入 | 7 2 1 2 3 1 2 3 1 |
| 输出 | 10 |
| 说明 | |

四、解题思路

核心思想

采用滑动窗口（双指针）+ 计数优化 的策略，通过右指针扩展窗口统计元素出现次数，当某个元素出现次数≥k 时，直接计算 "以当前右指针为终点的所有满足条件的子数组数"（n - r），避免逐个枚举子数组；同时左指针右移缩小窗口，继续探索更小的满足条件的窗口，最终累加所有符合条件的子数组数。

问题本质分析

表层问题：统计数组中 "包含至少 k 个相同元素" 的连续子数组总数；
深层问题：
1. 子数组的 "终点唯一性"：每个子数组有唯一的终点r，若找到第一个左边界l使得[l..r]满足条件，则所有左边界≤l、终点为r的子数组都满足条件，数量为n - r（无需重复计算）；
2. 滑动窗口的意义：用双指针维护 "当前元素计数"，避免重复遍历子数组，将时间复杂度从 O (n²) 优化到 O (n)；
3. 计数回退的必要性：右指针回退是为了抵消后续的自增操作，避免同一元素的计数被重复统计。

核心逻辑

计数统计：用哈希表记录滑动窗口内每个元素的出现次数；
条件触发：当某个元素计数≥k 时，直接累加n - r（以当前 r 为终点的满足条件的子数组数）；
窗口调整：左指针右移缩小窗口（尝试找更小的满足条件的窗口），右指针回退避免重复计数；
遍历终止：左 / 右指针遍历完数组，累加所有符合条件的子数组数。

步骤拆解
初始化
- 初始化结果ans=0，滑动窗口左右指针l=0、r=0，哈希表count记录窗口内元素计数；
- 进入循环（l < n && r < n）。
扩展右窗口
- 右指针r指向元素c，更新count[c] = count.getOrDefault(c,0)+1；
- 若count[c] ≥ k，触发条件统计。
条件统计与窗口调整
- 累加n - r到ans（以 r 为终点的满足条件的子数组数）；
- 左指针l右移：减少arr[l]的计数，l++；
- 右指针r回退：减少c的计数，r--（抵消后续的r++）。
继续遍历
- 右指针r++，继续扩展窗口；
- 循环直到l或r越界。
结果返回
- 循环结束后，返回ans（满足条件的子数组总数）。

五、代码实现

java 复制代码

import java.util.HashMap;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int k = sc.nextInt();

    Integer[] arr = new Integer[n];
    for (int i = 0; i < n; i++) {
      arr[i] = sc.nextInt();
    }

    System.out.println(getResult(arr, n, k));
  }

  public static Integer getResult(Integer[] arr, Integer n, Integer k) {
    int ans = 0;

    int l = 0;
    int r = 0;
    HashMap<Integer, Integer> count = new HashMap<>();

    while (l < n && r < n) {
      Integer c = arr[r];
      count.put(c, count.getOrDefault(c, 0) + 1);
      if (count.get(c) >= k) {
        ans += n - r;

        count.put(arr[l], count.get(arr[l]) - 1);
        l++;

        count.put(c, count.get(c) - 1);
        r--;
      }
      r++;
    }

    return ans;
  }
}