import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Solution {

    public static void main(String[] args) {
		Deque<String> deque = new ArrayDeque<>();
		Scanner sc = new Scanner(System.in);
		String input = sc.nextLine();
		String[] str = input.split(" ");
		int size = Integer.valueOf(str[0]);
		String s = sc.nextLine();
		sc.close();
		String[] s2 = s.split(" ");
		Set<String> set = new HashSet<>();
		int max = 0;
		for (int str1 = 0; str1 < Integer.valueOf(str[1]); str1++) {
			deque.offerLast(s2[str1]);
		}
		set.addAll(deque);
		max = set.size();
		
		for (int i = Integer.valueOf(str[1]) + 1; i < size; i++) {
			deque.pollFirst();
			deque.offerLast(s2[i]);
			set.clear();
			set.addAll(deque);
			max = Math.max(max, set.size());
		}
		
		System.out.println(max);
	}
}

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

import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Deque<Integer> deque = new LinkedList<>();
        Set<Integer> set = new HashSet<>();
        int maxUnique = 0;

        for (int i = 0; i < n; i++) {
            int num = scanner.nextInt();
            deque.add(num);
            set.add(num);

            if (deque.size() == m) {
                maxUnique = Math.max(maxUnique, set.size());
                int first = deque.removeFirst();
                if (!deque.contains(first)) {
                    set.remove(first);
                }
            }
        }
        scanner.close();
        System.out.println(maxUnique);
    }
}

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