合法连续子段

n, m = map(int, input().split())
arr = list(map(int, input().split()))
cnt = [0] * (n + 5)
cnt[arr[0]] = 1
r, ans = 1, 0
for l in range(1, n + 1):
    if r <= n and cnt[arr[r - 1]] < m:
        r += 1
        while r <= n:
            cnt[arr[r - 1]] += 1
            if cnt[arr[r - 1]] >= m:
                break
            r += 1
    ans += (n - r + 1)
    cnt[arr[l - 1]] -= 1
print(ans)

滑动窗口去处理，但是要注意一个子区间满足时，要不断移动左边界，计算符合要求的全部区间。例如m = 2,nums = [1,2,1,3,4]时，滑动窗口刚刚覆盖[1,2,1]时满足要求，但是[1,2,1,3],[1,2,1,3,4]同时也满足要求。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int len = s.nextInt(), m = s.nextInt();
        int[] nums = new int[len];
        for (int i = 0; i < len; i++) {
            nums[i] = s.nextInt();
        }
        int left = 0;
        long ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        boolean find = false;
        for (int right = 0; right < len; right++) {
            int times = map.getOrDefault(nums[right], 0);
            times++;
            map.put(nums[right], times);
            if (times == m) {
                find = true;
            }
            while (find) {
                ans += len - right;
                int leftTimes = map.get(nums[left]);
                leftTimes--;
                map.put(nums[left], leftTimes);
                if (nums[left] == nums[right] && leftTimes < m) {
                    find = false;
                }
                left++;
            }
        }
        System.out.println(ans);
    }
}

#include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
using namespace std;

int main(){
    int n = 0, m=0;
    cin>>n>>m;
    vector<int> nums(n);
    for(int i =0;i<n;i++){
        cin>>nums[i];
    }
    long long left = 0, right = 0, res = 0;
    unordered_map<int, int> mymap;
    mymap[nums[right]]++;
    while(left<n){
        while(mymap[nums[right]]<m){
            right ++;
            if(right == n)
                break;
            mymap[nums[right]] ++;
        }
        if(right == n){
            break;
        }
        res += (n - right);
        mymap[nums[left]]--;
        left++;
    }
    cout<<res<<endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n,m;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    while(cin >> n >> m){
        vector<int> a(n);
        for(int i = 0;i < n;i++){
            cin >> a[i];
        }
        //先找到刚好只有一个最大重复为m的所有区间。每个区间求向后的区间数
        unordered_map<int,int> cnt;
        ll res = 0;
        int l = 0, r = 0;
        while(r < n){
            cnt[a[r]]++;
            while(l<=r && cnt[a[r]] >= m){
                res += (n-r);
                cnt[a[l]]--;
                l++;
            }
            r++;
        }
        
        printf("%ld\n", res);
    }
}

import sys
import math

a = input().split()
n = int(a[0])
m = int(a[1])
a = list(int(i) for i in input().split())

res = 0
i = 0
dic = dict()
j = 0

while j < n:
        try:
            dic[a[j]] += 1            
        except:
            dic[a[j]] = 1

        while dic[a[j]] == m:
            res += n-j
            dic[a[i]] -= 1
            i += 1
        j += 1

print(res)

n, m = map(int, input().split())
nums = list(map(int, input().split()))

from collections import defaultdict
counter = defaultdict(int)
res = 0
j = 0
for i in range(n):
    counter[nums[i]] += 1
    while counter[nums[i]] == m:
        counter[nums[j]] -= 1
        j += 1
    res += j
print(res)

#include<bits/stdc++.h>
using namespace std;

int main(){
    uint64_t res = 0;
    int n, m;
    cin >> n >> m;
    int nums[n];
    for(int i = 0;i < n; i++) {
        cin >> nums[i];
    }
    unordered_map<int, int> cnt;
    for(int right = 0, left = 0; right < n; right++) {
        if(++cnt[nums[right]] == m) {
            res += (n-right);
            
            //当左窗口右缩的时候不用担心  m = 2  [4 3 1 2 1 2 3 7]
            //像 3 3会被漏算的情况 会被算进去的
            //小于等于是因为 m = 1 的样例
            while(left <= right && cnt[nums[right]] >= m) {
                cnt[nums[left]]--;
                left++;
                if(cnt[nums[right]] == m) {
                    res += (n-right);
                }
            }
        }
    }
    
    cout << res;
    return 0;
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

/**
 * @auther slience
 */
public class Main {


    public static long solve(int[] arr,int m){
       long res = 0;
       // 存放每个数出现的次数
        HashMap<Integer,Integer> map1 = new HashMap<>();
        HashSet<Integer> set =  new HashSet<>();
        int L=0;
        int R=L;
          while (L<arr.length){
             while(R<arr.length&&(set.size()==0)) {
                 if (map1.containsKey(arr[R])) {
                     map1.put(arr[R], map1.get(arr[R]) + 1);
                 } else {
                     map1.put(arr[R], 1);
                 }
                 if (map1.get(arr[R]) >= m) {
                     set.add(arr[R]);
                 }
                 R++;
             }
             if(set.size()!=0){
                 res+=arr.length-R+1;
             }
             map1.put(arr[L],map1.get(arr[L])-1);
             Integer number = map1.get(arr[L]);
             if(number<m){
                set.remove(arr[L]);
             }
             L++;
      }
        return res;
    }




        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[] arr =new  int[n];
            for(int i=0;i<arr.length;i++){
                arr[i]=scanner.nextInt();
            }
            System.out.println(solve(arr, m));
        }




}
大致思路：双指针模拟过程 解题  常坑人点用long接住