#include<iostream>
#include<fstream>
#include<vector>
#include<queue>
using namespace std;
ifstream in("dfs.in");
ofstream out("dfs.out");

class graf{
private:
    int NrNod, NrMuch;
    bool orientat;
    vector<vector<int>> tablouVecini;

public:
    graf(int NrNoduri = 0, int NrMuchii = 0, bool eOrientat = false){
        this->NrNod = NrNoduri;
        this->NrMuch = NrMuchii;
        this->orientat = eOrientat;
    }

    ~graf(){
        this->NrNod = 0;
        this->NrMuch = 0;
    }

    void set_NrNod(int &);
    void set_NrMuch(int &);
    void set_muchii(int, int);
    int get_NrNod();
    int get_NrMuch();
    void cit_muchii();
    void bfs(int, bool[], int[]);
    void dfs(int, bool[]);
    int nr_comp_conexe(bool[]);
};

void graf::set_NrNod(int &n){
    NrNod = n;
}

void graf::set_NrMuch(int &m){
    NrMuch = m;
}

int graf::get_NrNod(){
    return NrNod;
}

int graf::get_NrMuch(){
    return NrMuch;
}

void graf::set_muchii(int nod1, int nod2){
    tablouVecini[nod1].push_back(nod2);
}

void graf::cit_muchii(){
    int nod1, nod2;
    tablouVecini.resize(NrNod + 1);
    for(int i = 0; i < NrMuch; i++){
        in>>nod1>>nod2;
        set_muchii(nod1, nod2);
        if(!orientat){
            set_muchii(nod2, nod1);
        }
    }
}

void graf::bfs(int NodSursa, bool vizitat[], int distanta[]){
    queue<int> coada;
    coada.push(NodSursa);
    vizitat[NodSursa] = true;
    while(!coada.empty()){
        for(int nod : tablouVecini[coada.front()]){
            if(!vizitat[nod]){
                vizitat[nod] = 1;
                coada.push(nod);
                distanta[nod] = distanta[coada.front()] + 1;
            }
        }
        coada.pop();
    }
    for(int nod = 1; nod <= NrNod; nod++){
        if((NodSursa != nod) && (distanta[nod] == 0)){
            out<<"-1 ";
        }
        else{
            out<<distanta[nod]<<" ";
        }
    }
}

void graf::dfs(int nod, bool vizitate[]){
    vizitate[nod] = true;
    for(int vecin : tablouVecini[nod]){
        if(!vizitate[vecin]){
            dfs(vecin, vizitate);
        }
    }
}

int graf::nr_comp_conexe(bool vizitate[]){
    int nrCompCon = 0;
    for(int i = 1; i <= NrNod; i++){
        if(!vizitate[i]){
            nrCompCon++;
            dfs(i, vizitate);
        }
    }
    return nrCompCon;
}

void prob_bfs_IA(){
    int N, M, NodSursa;
    in>>N>>M>>NodSursa;
    graf G(N, M, true);
    G.cit_muchii();
    bool vizitat[N + 1] = {0};
    int distanta[N + 1] = {0};
    G.bfs(NodSursa, vizitat, distanta);
}

void prob_dfs_IA(){
    int N, M;
    in>>N>>M;
    graf G(N, M, false);
    G.cit_muchii();
    bool vizitat[N + 1] = {0};
    out<<G.nr_comp_conexe(vizitat);
}

int main()
{
    //prob_bfs_IA();
    prob_dfs_IA();
    return 0;
}