Самый длинный подмассив массива состоящий из одинаковых чисел, с удалением до k элементов

int quadratic(std::vector<int> const& vct, int const k)
{
    int kt = k, ns{}, max{}, maxt{};
    for (int i = 0; i < vct.size(); )
    {
        maxt = 0;
        ns = vct[i];
        kt = k;
 
        for (int j = i; j < vct.size() && kt > -1; ++j)
        {
            if (ns == vct[j])
                ++maxt;
            else
                --kt;
        }
        max = std::max(max, maxt);
        while (i < vct.size() && vct[i] == ns)
        {
            ++i;
        }
    }
    return max;
}

#include <iostream>
 
using namespace std;
 
static const int MAXN = 1000000 + 5;
 
int last_pos[MAXN];
int head_pos[MAXN];
int cnt[MAXN];
int prev_same[MAXN];
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n, k;
    cin >> n >> k;
 
    for (int i = 1; i <= n; ++i) {
        last_pos[i] = -1;
        head_pos[i] = -1;
        cnt[i] = 0;
    }
 
    int ans = 0;
 
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
 
        prev_same[i] = last_pos[x];
        last_pos[x] = i;
 
        if (head_pos[x] == -1)
            head_pos[x] = i;
 
        int c = ++cnt[x];
 
        while (i - head_pos[x] - (c - 1) > k) {
            head_pos[x] = prev_same[head_pos[x]];
            c = --cnt[x];
        }
 
        if (c > ans)
            ans = c;
    }
 
    cout << ans << '\n';
    return 0;
}

#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <algorithm>
#include <cassert>
#include <ranges>
namespace rng = std::ranges;
 
// линейная сложность
int linear(std::vector<int> const& vct, int const k)
{
    std::vector<int> vn(vct.size() + 1);
    int kt = k, ns{}, max{}, maxt{}, i{}, j{};
    for (i = 0; i < vct.size(); )
    {
        ns = vct[i];
        kt = k - (j - i - vn[vct[i]]);
        maxt = vn[vct[i]];
        for (; j < vct.size() && kt >= 0; ++j)
        {
            vn[vct[j]]++;
            if (vct[j] != ns)
                --kt;
            else
                ++maxt;
        }
        max = std::max(max, maxt);
        while (i < vct.size() && vct[i] == ns)
        {
            ++i;
            --vn[ns];
        }
    }
    return max;
}
 
// квадратичная сложность
int quadratic(std::vector<int> const& vct, int const k)
{
    int kt = k, ns{}, max{}, maxt{};
    for (int i = 0; i < vct.size(); )
    {
        maxt = 0;
        ns = vct[i];
        kt = k;
 
        for (int j = i; j < vct.size() && kt > -1; ++j)
        {
            if (ns == vct[j])
                ++maxt;
            else
                --kt;
        }
        max = std::max(max, maxt);
        while (i < vct.size() && vct[i] == ns)
        {
            ++i;
        }
    }
    return max;
}
 
int main()
{
    int const cnt = (int)1e4; // размер массива
    std::vector<int> vct(cnt); // массив
    std::mt19937 eng{ (unsigned)time(nullptr) };
    int uidMin = 1, uidMax = 100;
    if (uidMax >= cnt)
        throw;
    std::uniform_int_distribution<int> uid{ uidMin, uidMax };
    while (true)
    {
        for (auto& val : vct)
            val = uid(eng); // рандомно заполняем массив
        int k = uid(eng); // число k
 
        int maxLin = linear(vct, k);
        int maxQuad = quadratic(vct, k);
 
        std::cout << "k = " << k << "  " << maxLin << " == " << maxQuad << "\n";
        if (maxLin != maxQuad)
            throw 1;
    }
}

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
 
using namespace std;
 
int maxLengthWithKRemovals(int n, int k, const vector<int>& c) {
    unordered_map<int, int> freq; // Словарь для подсчёта частоты элементов
    int left = 0;
    int max_count = 0; // Максимальное количество одинаковых элементов в текущем окне
    int max_length = 0; // Максимальная длина последовательности
 
    for (int right = 0; right < n; ++right) {
        freq[c[right]]++;
        max_count = max(max_count, freq[c[right]]);
 
        // Условия сужения окна, если количество удалённых элементов больше k
        while ((right - left + 1) - max_count > k) {
            freq[c[left]]--;
            if (freq[c[left]] == 0) {
                freq.erase(c[left]); // Удаляем элемент из словаря, если его больше нет
            }
            left++;
        }
 
        // Обновляем максимальную длину
        max_length = max(max_length, right - left + 1);
    }
 
    return max_length;
}
 
int main() {
    int n, k;
    cin >> n >> k;
    vector<int> c(n);
    for (int i = 0; i < n; ++i) {
        cin >> c[i];
    }
 
    int result = maxLengthWithKRemovals(n, k, c);
    cout << result << endl;
 
    return 0;
}

for (; j < vct.size() && kt >= 0; ++j)