#include<set>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

set<int>se;

int n,k,x,ans;

int main(){

    freopen("del.in","r",stdin);

    freopen("del.out","w",stdout);

    scanf("%d%d",&n,&k);

    for(int i=;i<=n;i++){

        scanf("%d",&x);

        if(se.find(x)!=se.end())    k--;

        else{

            se.insert(x);

            ans++;

        }

    }

    if(k<=)    cout<<ans<<endl;

    else cout<<ans-k<<endl;

}

#include <iostream>

#include <cstdio>

#include <cstring>

#include <vector>

#include <algorithm>

#include <cstdlib>

using namespace std;

int board[][], isKing[][];

int dir[][] = {{, }, {, -}, {-, }, {-, -}};

int best_deep;

vector<int> w;

vector<int> ways;

void dfs(int step, int x, int y, int isKing)

{

    w.push_back(x *  + y);

    if (step > best_deep)

    {

        best_deep = step;

        ways.clear();

        ways.push_back(w[]);

    }

    else if (step >  && step == best_deep)

    {

        ways.push_back(w[]);

    }

    int dis_limit = isKing ?  : ;

    for (int d = ; d < ; d++)

    {

        bool pass = false;

        int passx = , passy = ;

        for (int dis = ; dis <= dis_limit; dis++)

        {

            int nxtX = x + dis * dir[d][];

            int nxtY = y + dis * dir[d][];

            if (!( <= nxtX && nxtX <  &&  <= nxtY && nxtY < ))

                break;

            if (board[nxtX][nxtY] ==  || board[nxtX][nxtY] == )

                break;

            if (pass && board[nxtX][nxtY] == )

                break;

            if (board[nxtX][nxtY] == )

            {

                pass = true;

                passx = nxtX;

                passy = nxtY;

            }

            else

            {

                if (!pass)

                    continue;

                board[passx][passy] = ;

                dfs(step + , nxtX, nxtY, isKing);

                board[passx][passy] = ;

            }

        }

    }

    w.pop_back();

}

bool getAvailable()

{

    ways.clear();

    w.clear();

    best_deep = ;

    for (int curX = ; curX < ; curX++)

        for (int curY = ; curY < ; curY++)

            if (board[curX][curY] == )

                dfs(, curX, curY, isKing[curX][curY]);

    if (best_deep == )

    {

        for (int curX = ; curX < ; curX++)

            for (int curY = ; curY < ; curY++)

                if (board[curX][curY] == )

                {

                    if (isKing[curX][curY])

                    {

                        for (int x = curX + , y = curY + ;  <= x && x <  &&  <= y && y < ; x++, y++)

                            if (!board[x][y])

                                ways.push_back(curX *  + curY);

                            else

                                break;

                        for (int x = curX + , y = curY - ;  <= x && x <  &&  <= y && y < ; x++, y--)

                            if (!board[x][y])

                                ways.push_back(curX *  + curY);

                            else

                                break;

                        for (int x = curX - , y = curY + ;  <= x && x <  &&  <= y && y < ; x--, y++)

                            if (!board[x][y])

                                ways.push_back(curX *  + curY);

                            else

                                break;

                        for (int x = curX - , y = curY - ;  <= x && x <  &&  <= y && y < ; x--, y--)

                            if (!board[x][y])

                                ways.push_back(curX *  + curY);

                            else

                                break;

                    }

                    else

                    {

                        if (curX -  >=  && curY -  >=  && !board[curX - ][curY - ])

                            ways.push_back(curX *  + curY);

                        if (curX -  >=  && curY +  <  && !board[curX - ][curY + ])

                            ways.push_back(curX *  + curY);

                    }

                }

    }

    if (!ways.size())

        return false;

    return true;

}

int main(){

    freopen("chess.in", "r", stdin);

    freopen("chess.out", "w", stdout);

    memset(board, , sizeof(board));

    memset(isKing, , sizeof(isKing));

    for (int i = ; i < ; i++)

        for (int j = ; j < ; j++)

        {

            char c;

            scanf(" %c", &c);

            board[i][j] = c - '';

        }

    for (int i = ; i < ; i++)

        for (int j = ; j < ; j++)

        {

            char c;

            scanf(" %c", &c);

            isKing[i][j] = c - '';

        }

    getAvailable();

    if (!ways.size())

        printf("0\n");

    else {

        sort(ways.begin(), ways.end());

        printf("%d\n", (int)ways.size());

        for (int i = ; i < (int)ways.size(); i++)

            printf("(%d,%d)\n", ways[i] /  + , ways[i] %  + );

    }

}

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

int n,k,x,y;

int w[],f[];

double dp[][];

int main(){

    freopen("bonus.in","r",stdin);

    freopen("bonus.out","w",stdout);

    scanf("%d%d",&n,&k);

    for(int i=;i<n;i++){

        scanf("%d",&w[i]);

        while(scanf("%d",&x)&&x) f[i]|=<<x-;

    }

    for(int s=;s<(<<n);s++) dp[k][s]=;

    for(int i=k-;i>=;i--)

        for(int s=;s<(<<n);s++)

            for(int j=;j<n;j++)

                if((s&f[j])==f[j]) dp[i][s]+=1.0/n*max(dp[i+][s],dp[i+][s|(<<j)]+w[j]);

                else dp[i][s]+=1.0/n*dp[i+][s];

    printf("%.6f\n",dp[][]);

}