#include <cstdio>
#include <vector>
#include <algorithm>

#include <cstdio>
#include <cstring>
#include <cstdint>
#include <cstdlib>
#include <cstddef>

#include <type_traits>

namespace FastIn {
  static constexpr size_t BUF_SIZE=1<<17, INT_LEN=24, FLT_LEN=400;
  static char buf[BUF_SIZE|1]={}, *pos=buf, *endbuf=nullptr;
 
  inline bool rebuffer() {
    size_t rest=endbuf-pos;
    if (static_cast<ptrdiff_t>(rest) > pos-buf) {
      // not disjoint
      return true;
    }
 
    // disjoint
    std::memcpy(buf, pos, rest);
 
    pos = buf;
 
    size_t len=std::fread(pos+rest, 1, BUF_SIZE-rest, stdin);
    *(endbuf = buf + (rest+len)) = 0;
 
    return *pos;
  }
 
  inline bool scan(char &in) {
    if ((in = *pos)) {
      ++pos;
      return true;
    }
 
    return rebuffer() && (in = *pos++);
  }
 
  inline bool scan(char *in) {
    if ((*in = *pos) == 0) {
      if (rebuffer() && (*in = *pos) == 0) {
        return false;
      }
    }
    ++in;
    while (true) {
      if ((*in = *pos++) == 0) {
        if (rebuffer() && (*in = *pos++) == 0) {
          return true;
        }
      }
      ++in;
    }
  }
 
  inline bool scan(double &in) {
    if (pos + FLT_LEN >= endbuf && !rebuffer()) {
      in = 0.0;
      return false;
    }
 
    char *tmp;
    in = std::strtod(pos, &tmp);
    pos = tmp;
    return true;
  }
 
  template <class Int>
  inline bool scan(
      Int &in,
      typename std::enable_if<std::is_signed<Int>::value>::type *un=nullptr
  ) {
    in = 0;
 
    // assume that no redundant whitespace appears
    if (pos + INT_LEN >= endbuf && !rebuffer()) {
      return false;
    }
 
    // assume that ' ' < '+' < '-' < '0' < '9'
    while (*pos < '-') {
      ++pos;
    }
 
    bool neg=false;
    if (*pos == '-') {
      ++pos;
      neg = true;
    }
 
    // assume that numbers are separated by the character whose value is
    // less than '0' (e.g. whitespaces, newlines)
    do {
      in = in*10 + (*pos)-'0';
    } while (*++pos >= '0');
 
    if (neg) {
      in = -in;
    }
    return true;
  }
 
  template <class Int>
  inline bool scan(
      Int &in,
      typename std::enable_if<!std::is_signed<Int>::value>::type *un=nullptr
  ) {
    in = 0;
 
    // assume that no redundant whitespace appears
    if (pos + INT_LEN >= endbuf && !rebuffer()) {
      return false;
    }
 
    // assume that ' ' < '0' < '9' and minus signs do not appear
    //while (*pos < '0') {
    //  ++pos;
    //}
 
    // assume that numbers are separated by the character whose value is
    // less than '0' (e.g. whitespaces, newlines)
    do {
      in = in*10 + (*pos)-'0';
    } while (*++pos >= '0');
 
    ++pos;
    return true;
  }
 
  inline bool eat() {
    if (*pos > ' ') {
      return true;
    }
 
    do {
      if (*pos == 0 && !rebuffer()) {
        return false;
      }
    } while (*++pos <= ' ');
 
    return true;
  }
      
  inline bool eat(char ch) {
    if (*pos == ch) {
      return true;
    }
 
    do {
      if (*pos == 0 && !rebuffer()) {
        return false;
      }
    } while (*++pos != ch);
 
    return true;
  }
 
  class Scanner {
    bool rebuffer() {
      return FastIn::rebuffer();
    }
 
  public:
    Scanner() {
      endbuf = pos + std::fread(buf, 1, BUF_SIZE, stdin);
    }
 
    template <class T>
    inline bool scan(T &in) {
      return FastIn::scan(in);
    }
 
    template <class First, class... Rest>
    inline bool scan(First &in, Rest &...ins) {
      return scan(in) && scan(ins...);
    }
  };
}

template <class RandomIt>
void rxsort(RandomIt first, RandomIt last) {
  using IntType = typename RandomIt::value_type;
  intmax_t cur_shift=0, max_exp=sizeof(IntType);
  std::vector<IntType> work(last-first);
  for (int i=0; i<max_exp; ++i) {
    size_t num[256]={};

    for (RandomIt it=first; it<last; ++it)
      ++num[((*it)>>cur_shift)&255];

    {
      size_t tmp=0;
      for (int j=0; j<256; ++j)
        std::swap(tmp, num[j]+=tmp);
    }

    for (RandomIt it=first; it<last; ++it)
      work[num[((*it)>>cur_shift)&255]++] = *it;

    {
      size_t j=0;
      for (RandomIt it=first; it<last; ++it)
        *it = work[j++];
    }

    cur_shift += 8;
  }

  if (!std::is_signed<IntType>::value) return;

  RandomIt mid=last;
  for (RandomIt it=last; --it>=first;)
    if (*it >= 0) {
      mid = ++it;
      break;
    }

  if (mid == last)
    return;

  std::copy(first, mid, work.begin()+(last-mid));
  std::copy(mid, last, work.begin());
  std::copy(work.begin(), work.end(), first);
}

FastIn::Scanner cin;

int main() {
  int N, K;
  cin.scan(N, K);

  if (N == K) {
    printf("0\n");
    return 0;
  }

  std::vector<int> A(N+1);
  for (int i=0; i<N; ++i) {
    int a;
    cin.scan(a);
    ++A[a];
  }

  rxsort(A.begin(), A.end());

  int nonzero=std::upper_bound(A.begin(), A.end(), 0)-A.begin();
  K += nonzero;

  int res=0;
  for (int i=nonzero; i<N; ++i) {
    if (N < K) break;

    if (A[i]) {
      res += A[i];
      ++K;
    }
  }

  printf("%d\n", res);
  return 0;
}


Measured memory_bytes: 1920