#include <bits/stdc++.h>

using namespace std;

ifstream f("bfs.in");
ofstream g("bfs.out");

class graf
{
    int nr_noduri, nr_muchii;

    vector<vector<int> > lista_muchii;

    bool orientat;

public:
    graf();

    graf(int nr_noduri, int nr_muchii, bool orientat);

    ~graf() {}

    void BFS(int start);

    void DFS();

};

graf::graf()
{
    nr_noduri = 0;
    nr_muchii = 0;
    orientat = 0;
}

graf::graf(int nr_noduri, int nr_muchii, bool orientat)
{
    int i = 0, nod1, nod2;

    lista_muchii.resize(nr_noduri+1);

    this->nr_noduri = nr_noduri;
    this->nr_muchii = nr_muchii;
    this->orientat = orientat;

    while(i < nr_muchii)
    {
        f>>nod1>>nod2;
        if(orientat)
            lista_muchii[nod1].push_back(nod2);
        else
        {
            lista_muchii[nod1].push_back(nod2);
            lista_muchii[nod2].push_back(nod1);
        }
        i++;
    }
}

///----------------------------------------------------------------------------------bfs
void graf::BFS(int inceput)
{
    int i = 0, nod_curent;

    queue<int> q;

    vector<int>vizitat;
    vector<int>distanta;

    q.push(inceput);

    do
    {
        vizitat.push_back(0);
        distanta.push_back(-1);
        i++;

    }
    while(i <= nr_noduri);

    vizitat[inceput] = 1;
    distanta[inceput] = 0;

    while(!q.empty())
    {
        nod_curent = q.front();
        q.pop();
        for (auto j = lista_muchii[nod_curent].begin(); j != lista_muchii[nod_curent].end(); j++)
            if(!vizitat[*j])
            {
                vizitat[*j] = 1;
                q.push(*j);
                distanta[*j] = distanta[nod_curent] + 1;
            }
    }
    int marime = distanta.size();
    for(i = 1; i < marime; i++)
        g<<distanta[i]<<" ";
}
///----------------------------------------------------------------------------------DFS

void graf::DFS()
{
    int i, j, nr = 0, v, varf, marime;

    vector<int> vizitat;

    stack<int> comp;
    for(i = 0; i < nr_noduri + 1; i++)
        vizitat.push_back(0);

    for(i = 1; i < nr_noduri + 1; i++)
        if(vizitat[i] == 0)
        {
            comp.push(i);
            vizitat[i] = 1;

            while(!comp.empty())
            {
                varf = comp.top();
                v = 0;
                marime = lista_muchii[varf].size();
                int ok = 0;
                for(j = 0; j < marime && ok == 0; j++)
                    if(vizitat[lista_muchii[varf][j]] == 0)
                    {
                        v = lista_muchii[varf][j];
                        ok = 1;
                    }
                if(v)
                    {
                       comp.push(v);
                        vizitat[v] = 1;
                    }
                else
                    comp.pop();
            }
            nr++;
        }
    g<<nr;
}


int main()
{
    int n, m, s;
    f>>n>>m;
    graf test(n,m,0);

    test.DFS();
    return 0;
}