Problem:
Score : 300 points

Problem Statement

Takahashi has N balls. Initially, an integer A_i is written on the i-th ball.

He would like to rewrite the integer on some balls so that there are at most K different integers written on the N balls.

Find the minimum number of balls that Takahashi needs to rewrite the integers on them.

Constraints

1 \leq K \leq N \leq 200000

1 \leq A_i \leq N

All input values are integers.

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 ... A_N

Output

Print the minimum number of balls that Takahashi needs to rewrite the integers on them.

Sample Input 1

5 2
1 1 2 2 5

Sample Output 1

1

For example, if we rewrite the integer on the fifth ball to 2, there are two different integers written on the balls: 1 and 2.
On the other hand, it is not possible to rewrite the integers on zero balls so that there are at most two different integers written on the balls, so we should print 1.

Sample Input 2

4 4
1 1 2 2

Sample Output 2

0

Already in the beginning, there are two different integers written on the balls, so we do not need to rewrite anything.

Sample Input 3

10 3
5 1 3 2 4 1 1 2 3 4

Sample Output 3

3

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintWriter;
    import java.math.BigInteger;
    import java.util.Arrays;
    import java.util.InputMismatchException;
     
    public class Main
    {
    	InputStream is;
    	PrintWriter out;
    	String INPUT = "";
    	
    	void solve()
    	{
    		int n=ni(),k=ni(),max=0,min=999999999;
    		int[] freq=new int[200001];
    		for(int i=0;i<n;i++) {
    			int v=ni();
    			freq[v]++;
    			min=Math.min(min,v);
    			max=Math.max(max,v);
    		}
    		long ans=0;
    		while(max-min>k) {
    			if(freq[max]>freq[min]) {
    				ans+=freq[min];
    				min++;
    			}
    			else {
    				ans+=freq[max];
    				max--;
    			}
    		}
    		
    		out.println(ans);
    		
    	}
    	
    	
    	
    	
    	
    	void run() throws Exception
    	{
    		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
    		out = new PrintWriter(System.out);
    		
    		long s = System.currentTimeMillis();
    		solve();
    		out.flush();
    		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
    	}
    	
    	public static void main(String[] args) throws Exception 
    	{ new Main().run(); }
    	
    	private byte[] inbuf = new byte[1024];
    	public int lenbuf = 0, ptrbuf = 0;
    	
    	private int readByte()
    	{
    		if(lenbuf == -1)throw new InputMismatchException();
    		if(ptrbuf >= lenbuf)
    		{
    			ptrbuf = 0;
    			try 
    			{ lenbuf = is.read(inbuf); } 
    			catch (IOException e) 
    			{ throw new InputMismatchException(); }
    			if(lenbuf <= 0)return -1;
    		}
    		return inbuf[ptrbuf++];
    	}
    	
    	private boolean isSpaceChar(int c)
    	{ return !(c >= 33 && c <= 126); }
    	private int skip() 
    	{ int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
    	
    	private double nd() 
    	{ return Double.parseDouble(ns()); }
    	private char nc()
    	{ return (char)skip(); }
    	
    	private String ns()
    	{
    		int b = skip();
    		StringBuilder sb = new StringBuilder();
    		while(!(isSpaceChar(b)))
    		{ // when nextLine, (isSpaceChar(b) && b != ' ')
    			sb.appendCodePoint(b);
    			b = readByte();
    		}
    		return sb.toString();
    	}
    	
    	private char[] ns(int n)
    	{
    		char[] buf = new char[n];
    		int b = skip(), p = 0;
    		while(p < n && !(isSpaceChar(b)))
    		{
    			buf[p++] = (char)b;
    			b = readByte();
    		}
    		return n == p ? buf : Arrays.copyOf(buf, p);
    	}
    	
    	private char[][] nm(int n, int m)
    	{
    		char[][] map = new char[n][];
    		for(int i = 0;i < n;i++)map[i] = ns(m);
    		return map;
    	}
    	
    	private int[] na(int n)
    	{
    		int[] a = new int[n];
    		for(int i = 0;i < n;i++)a[i] = ni();
    		return a;
    	}
    	
    	private int ni()
    	{
    		int num = 0, b;
    		boolean minus = false;
    		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
    		if(b == '-')
    		{
    			minus = true;
    			b = readByte();
    		}
    		
    		while(true)
    		{
    			if(b >= '0' && b <= '9')
    			{
    				num = num * 10 + (b - '0');
    			}else
    			{
    				return minus ? -num : num;
    			}
    			b = readByte();
    		}
    	}
    	
    	private long nl()
    	{
    		long num = 0;
    		int b;
    		boolean minus = false;
    		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
    		if(b == '-')
    		{
    			minus = true;
    			b = readByte();
    		}
    		
    		while(true){
    			if(b >= '0' && b <= '9')
    			{
    				num = num * 10 + (b - '0');
    			}else
    			{
    				return minus ? -num : num;
    			}
    			b = readByte();
    		}
    	}
    	
    	private static void tr(Object... o) 
    	{ System.out.println(Arrays.deepToString(o)); }
    }