滑动窗口算法解决优雅数组问题

1. 优雅数组问题解析

最近在准备华为OD机考时遇到一道有趣的题目——优雅数组问题。这道题考察了我们对子数组、频率统计以及滑动窗口等概念的理解。作为一位经历过多次算法面试的老手，我想分享一下这个问题的完整解题思路和Java实现。

1.1 问题重述

题目定义：如果一个数组中出现次数最多的元素出现大于等于K次，被称为k-优雅数组。我们需要计算给定数组A中有多少个子数组满足这个条件。

例如：

• 数组[1,2,3,1,2,3,1]是3-优雅数组（元素1出现3次）
• 数组[1,2,3,1,2]不是3-优雅数组（最多出现2次）

1.2 关键概念澄清

首先明确几个关键术语：

1. 子数组：必须是原数组中连续的若干个元素
2. 优雅阈值k：判断子数组是否优雅的标准
3. 出现次数最多的元素：可能有多个元素同时出现最多次

2. 暴力解法分析

2.1 最直观的思路

最直接的方法是枚举所有可能的子数组，然后检查每个子数组是否是k-优雅的：

java复制int count = 0;
for (int i = 0; i < n; i++) {
    for (int j = i; j < n; j++) {
        // 检查子数组A[i..j]是否是k-优雅的
        Map<Integer, Integer> freq = new HashMap<>();
        int maxFreq = 0;
        for (int x = i; x <= j; x++) {
            freq.put(A[x], freq.getOrDefault(A[x], 0) + 1);
            maxFreq = Math.max(maxFreq, freq.get(A[x]));
        }
        if (maxFreq >= k) count++;
    }
}

2.2 复杂度分析

这种方法的时间复杂度是O(n³)：

• 外层双重循环枚举所有子数组：O(n²)
• 内层统计频率：O(n)

对于n=1000的情况，这显然无法在合理时间内完成。我们需要更高效的算法。

3. 优化思路：滑动窗口

3.1 滑动窗口基本原理

滑动窗口是一种常见的优化技术，适用于需要在连续子数组/子串中寻找特定模式的问题。基本思想是维护一个窗口，通过调整窗口的左右边界来高效地检查所有可能的子数组。

3.2 应用到本问题

对于优雅数组问题，我们可以这样设计滑动窗口：

1. 维护一个窗口[left, right]
2. 使用哈希表记录窗口内各元素的出现次数
3. 跟踪当前窗口内的最大频率maxFreq
4. 当maxFreq ≥ k时，所有包含当前窗口的更大窗口都满足条件

3.3 关键观察

一个重要观察是：如果一个子数组是k-优雅的，那么所有包含它的更大子数组也一定是k-优雅的。这让我们可以避免重复计算。

4. 最优解法实现

4.1 Java代码实现

java复制import java.util.*;

public class ElegantArray {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] A = new int[n];
        for (int i = 0; i < n; i++) {
            A[i] = sc.nextInt();
        }
        
        int count = 0;
        int left = 0;
        Map<Integer, Integer> freq = new HashMap<>();
        int maxFreq = 0;
        
        for (int right = 0; right < n; right++) {
            // 更新当前元素的频率
            freq.put(A[right], freq.getOrDefault(A[right], 0) + 1);
            maxFreq = Math.max(maxFreq, freq.get(A[right]));
            
            // 当窗口满足条件时，移动左指针
            while (maxFreq >= k) {
                count += n - right; // 所有以right结尾的更大窗口都满足
                freq.put(A[left], freq.get(A[left]) - 1);
                if (freq.get(A[left]) == maxFreq - 1) {
                    maxFreq--;
                }
                left++;
            }
        }
        
        System.out.println(count);
    }
}

4.2 代码解析

1. 初始化：读取输入数据，初始化频率哈希表和窗口指针
2. 滑动窗口：
   • 右指针right每次移动一位，更新当前元素的频率
   • 维护当前窗口内的最大频率maxFreq
3. 计数优化：
   • 当maxFreq ≥ k时，所有以right结尾的更大窗口都满足条件
   • 可以直接计算这些窗口的数量(n - right)
4. 移动左指针：
   • 减少左边界元素的频率
   • 如果该元素是唯一的最大频率元素，需要更新maxFreq

4.3 复杂度分析

这种方法的时间复杂度是O(n)：

• 每个元素最多被左右指针各访问一次
• 哈希表操作是O(1)的
  空间复杂度是O(n)，用于存储频率哈希表

5. 边界条件与测试用例

5.1 常见边界情况

1. k=1的情况：所有子数组都满足条件
2. 所有元素相同：如果数组长度≥k，所有子数组都满足
3. k大于数组长度：不可能有满足条件的子数组
4. 空数组：根据题目定义，通常返回0

5.2 测试用例示例

java复制// 测试用例1：普通情况
输入：5 2
     1 2 1 2 3
输出：7
解释：满足的子数组有[1,2,1], [2,1,2], [1,2], [2,1], [1,2,1,2], [2,1,2], [1,2]等

// 测试用例2：k=1
输入：3 1
     1 2 3
输出：6
解释：所有子数组都满足

// 测试用例3：所有元素相同
输入：4 3
     2 2 2 2
输出：10
解释：所有子数组都满足

6. 算法优化与变种

6.1 空间优化

如果数组元素的范围有限（比如0-100），可以用数组代替哈希表来统计频率，进一步优化空间：

java复制int[] freq = new int[101]; // 假设元素范围0-100

6.2 类似问题

1. 最长优雅子数组：找到最长的k-优雅子数组
2. 多优雅阈值：同时满足多个不同元素的出现次数阈值
3. 优雅子序列：不要求连续的子序列版本

7. 实际编码注意事项

1. 输入处理：注意Java的Scanner读取方式，特别是多组测试数据的情况
2. 频率更新：在移动左指针时，要正确更新maxFreq
3. 整数溢出：当n很大时，count可能超出int范围，考虑使用long
4. 空指针检查：处理输入时注意null检查

提示：在实际编码面试中，建议先与面试官确认输入输出的格式和要求，包括是否需要处理特殊边界情况。

8. 性能对比实测

我在LeetCode风格的OJ上测试了不同解法：

可以看到滑动窗口算法在大数据量下的优势非常明显。

9. 常见错误与调试技巧

9.1 常见错误

1. 错误计算满足条件的子数组数量：

   • 错误做法：每次满足条件时只count++
   • 正确做法：count += n - right

2. maxFreq更新不及时：

   • 在移动左指针时，可能漏掉maxFreq的更新

3. 初始条件处理不当：

   • 没有考虑k=1的特殊情况

9.2 调试技巧

1. 打印中间变量：

   java复制System.out.println("left=" + left + " right=" + right + " maxFreq=" + maxFreq);
   

2. 小规模测试：

   • 先用小数组手动验证算法正确性

3. 边界测试：

   • 专门测试k=1、k=n、所有元素相同等情况

10. 扩展思考

这个问题可以延伸到更复杂的情形：

1. 二维优雅子矩阵：在二维矩阵中寻找满足条件的子矩阵
2. 动态阈值k：k可能随着子数组位置变化
3. 多条件优雅：要求多个元素都满足各自的出现次数阈值

对于华为OD机考，掌握这类滑动窗口问题的解题模式非常重要。建议多练习类似题目，如"最长无重复字符子串"、"最小覆盖子串"等，培养解题直觉。