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

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

class graph{

    int n;
    static const int nmax = 100005;
    vector < int > G[nmax];
    queue < int > Bfs;
    vector < bool > vis;

    void bfs(int source)
    {
        vector < int > nodes;

        nodes.resize(n + 1, -1);

        Bfs.push(source); nodes[source] = 0;

        while(!Bfs.empty())
        {
            int node = Bfs.front();
            Bfs.pop();

            for(int i = 0; i < G[node].size(); ++i)
            {
                int nnode = G[node][i];
                if(nodes[nnode] == -1)
                {
                    nodes[nnode] = nodes[node] + 1;
                    Bfs.push(nnode);
                }
            }
        }

        for(int i = 1; i <= n; ++i)
            out << nodes[i] << " ";
    }

    void dfs(int node)
    {
        vis[node] = 1;

        for(int i = 0; i < G[node].size(); ++i)
        {
            int nnode = G[node][i];

            if(vis[nnode] == 0)
                dfs(nnode);
        }
    }

public:

    void read_bfs()
    {
        int m, s, x, y;

        in >> n >> m >> s;

        for(int i = 0; i < m; ++i)
        {
            in >> x >> y;
            G[x].push_back(y);
        }

        bfs(s);
    }

    void read_dfs()
    {
        int m, x, y, ct = 0;

        vis.resize(n + 1, false);

        in >> n >> m;

        for(int i = 0; i < m; ++i)
        {
            in >> x >> y;

            G[x].push_back(y);
            G[y].push_back(x);
        }

        for(int i = 1; i <= n; ++i)
            if(vis[i] == 0)
            {
                ++ct;
                dfs(i);
            }

        out << ct;
    }

};

int main()
{
    graph G;
    G.read_dfs();
    return 0;
}