优雅子数组

一、题目描述

如果一个数组中出现次数最多的元素出现大于等于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 - 优雅子数组的总数。

三、示例

四、解题思路

1. 核心思想

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

2. 问题本质分析

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

3. 核心逻辑

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

4. 步骤拆解

1. 初始化

   • 初始化结果ans=0，滑动窗口左右指针l=0、r=0，哈希表count记录窗口内元素计数；
   • 进入循环（l < n && r < n）。

2. 扩展右窗口

   • 右指针r指向元素c，更新count[c] = count.getOrDefault(c,0)+1；
   • 若count[c] ≥ k，触发条件统计。

3. 条件统计与窗口调整

   • 累加n - r到ans（以 r 为终点的满足条件的子数组数）；
   • 左指针l右移：减少arr[l]的计数，l++；
   • 右指针r回退：减少c的计数，r--（抵消后续的r++）。

4. 继续遍历

   • 右指针r++，继续扩展窗口；
   • 循环直到l或r越界。

5. 结果返回

   • 循环结束后，返回ans（满足条件的子数组总数）。

五、代码实现

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;
  }
}