My solution.

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Deque<Integer> deque = new ArrayDeque<>();
        Map<Integer, Integer> numCount = new HashMap<>();
        int max = 0;
        int n = in.nextInt();
        int m = in.nextInt();

        for (int i = 0; i < n; i++) {
            int num = in.nextInt();
            deque.offerLast(num);
            numCount.merge(num, 1, Integer::sum);

            if (deque.size() > m) {
                Integer val = deque.pollFirst();
                if (numCount.merge(val, -1, Integer::sum) == 0) {
                    numCount.remove(val);
                }
            }

            if (deque.size() == m && numCount.size() > max) {
                max = numCount.size();
            }
        }

        in.close();

        System.out.println(max);
    }

My attempt:

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Deque<Integer> deque = new LinkedList<>();
        
        int n = sc.nextInt();
        int m = sc.nextInt();
        int maxUniqueNumbers = 0;
        
        Map<Integer, Integer> frequencyMap = new HashMap<>(n);
                
        for (int i = 0; i < n; i++) {
            
            int currentInt = sc.nextInt();
            deque.addLast(currentInt);
            frequencyMap.compute(currentInt, (k, v) -> Objects.isNull(v) ? 1 : v+1);
            
            if (deque.size() != m) continue;
                
            if (frequencyMap.size() > maxUniqueNumbers) maxUniqueNumbers = frequencyMap.size();
            
            frequencyMap.compute(deque.pollFirst(), (k, v) -> v <= 1 ? null : v-1);
            
        }
            
        System.out.println(maxUniqueNumbers);
    }
}

import java.util.*;

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

    int numberElements = scanner.nextInt();       // Declare and initialize
    int numberSubgroups = scanner.nextInt();      // Declare and initialize

    Deque<Integer> elementsWindow = new ArrayDeque<>(numberSubgroups); // Declare and initialize
    int maxUniqueValues = 1;
    HashMap<Integer, Integer> frequency = new HashMap<>(numberElements); // Declare and initialize

    for (int i = 0; i < numberElements; i++) {
        int element = scanner.nextInt();
        elementsWindow.addLast(element);

        if (!frequency.containsKey(element)) {
            frequency.put(element, 1);
        } else {
            frequency.put(element, frequency.get(element) + 1);
        }

        if (elementsWindow.size() == numberSubgroups) {
            int numInFrequency = 0;
            for (int value : frequency.values()) {
                if (value > 0) {
                    numInFrequency++;
                }
            }
            maxUniqueValues = Math.max(maxUniqueValues, numInFrequency);

            Integer elementRemoved = elementsWindow.removeFirst();
            int updatedCount = frequency.get(elementRemoved) - 1;
            if (updatedCount == 0) {
                frequency.remove(elementRemoved);
            } else {
                frequency.put(elementRemoved, updatedCount);
            }
        }
    }

    System.out.println(maxUniqueValues);
    scanner.close();
}

}

My version:

 public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int numberElements = scanner.nextInt();
    int numberSubgroups = scanner.nextInt();
    Deque<Integer> elementsWindow = new ArrayDeque<>(numberSubgroups);
    int maxUniqueValues = 1;
    HashMap<Integer, Integer> frecuencia = new HashMap<>(numberElements);

    for (int i = 0; i < numberElements; i++) {
        int element = scanner.nextInt();
        elementsWindow.addLast(element);
        frecuencia.put(element, frecuencia.getOrDefault(element, 0) + 1);

        if (elementsWindow.size() == numberSubgroups) {
            int numInFrecuencia = frecuencia.size();

            maxUniqueValues = Math.max(maxUniqueValues, numInFrecuencia);
            Integer elementRemoved = elementsWindow.removeFirst();
            int updatedCount = frecuencia.get(elementRemoved) - 1;

            if (updatedCount == 0) {
                frecuencia.remove(elementRemoved);
            } else {
                frecuencia.put(elementRemoved, updatedCount);
            }
        }

    }
    System.out.println(maxUniqueValues);
}