#include <iostream>
#include <vector>
#include <fstream>
#include <queue>
using namespace std;

ifstream fin("dfs.in");
ofstream fout("dfs.out");

class graf {
    int nrN;
    int nrM;
    vector<vector<int>> matriceAd;

public:
    graf(int n, int m, vector<vector<int>> &mat) {
        nrN = n;
        nrM = m;
        matriceAd = mat;
    }

    void citire_neorientat() {
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin >> x >> y;
            matriceAd[x].push_back(y);
            matriceAd[y].push_back(x);
        }
    }

    void citire_orientat() {
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin >> x >> y;
            matriceAd[x].push_back(y);
        }
    }

    void citire_sortaret(vector<int> &dep){
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin>>x>>y;
            matriceAd[x].push_back(y);
            dep[y]++;
        }
    }

    void BFS(int S) {
        queue<int> coada;
        int x, y;
        vector<int> cost(nrN + 1, -1);
        cost[S] = 0;
        coada.push(S);
        while (!coada.empty()) {
            x = coada.front();
            coada.pop();
            for (int i = 0; i < matriceAd[x].size(); ++i) {
                if (cost[matriceAd[x][i]] == -1) {
                    cost[matriceAd[x][i]] = cost[x] + 1;
                    coada.push(matriceAd[x][i]);
                }
            }
        }
        for (int i = 1; i < nrN + 1; i++)
            fout << cost[i] << " ";
    }

    void DFS() {
        queue<int> coada;
        vector<int> viz(nrN + 1, 0);
        int conex = 0;
        for (int i = 1; i <= nrN; ++i) {
            if (viz[i] == 0) {
                conex++;
                coada.push(i);
                while (!coada.empty()) {
                    int x = coada.front();
                    viz[x]++;
                    coada.pop();
                    for (int j = 1; j < matriceAd[x].size(); ++j) {
                        if (viz[matriceAd[x][j]] == 0)
                            coada.push(matriceAd[x][j]);
                    }
                }
            }
        }
        fout << conex;
    }

    void sortaret(vector<int> &dep){
        queue<int> coada;
        vector<int> sortare;
        for (int i = 1; i < nrN + 1; ++i) {
            if (dep[i] == 0)
                coada.push(i);
        }
        while (!coada.empty()){
            int x = coada.front();
            sortare.push_back(x);
            coada.pop();
            for (int i = 1; i < matriceAd[x].size(); ++i) {
                dep[matriceAd[x][i]]--;
                if (dep[matriceAd[x][i]] == 0)
                    coada.push(matriceAd[x][i]);
            }
        }
        for (int i = 0; i < nrN; ++i) {
            fout<<sortare[i]<<" ";
        }
    }
};
///BFS
//int main(){
//    int n, m, S;
//    fin >> n >> m >> S;
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_orientat();
//    G.BFS(S);
//
//    return 0;
//}

///DFS
int main(){
    int n, m;
    fin>>n>>m;
    vector<vector<int>> mat;
    vector<int> aux(1,-1);
    mat.resize(n+1, aux);
    graf G(n, m, mat);
    G.citire_neorientat();
    G.DFS();
    return 0;
}

///sortaret
//int main(){
//    int n, m;
//    fin>>n>>m;
//    vector<int> dep(n + 1, 0);
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_sortaret(dep);
//    G.sortaret(dep);
//    return 0;
//}