#include<bits/stdc++.h>
using namespace std;

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

class Graf {

private:

    int m_nodes,m_edges;
    bool m_isDirected;
    bool m_haveCost;
    vector<int> adjList[100001];

public:
    Graf(int mNodes, int mEdges, bool mIsDirected, bool mHaveCost);
    void add_Edge(int from, int to);

    //problema BFS infoarena
    // al i-lea numar reprezinta numarul minim de arce ce trebuie parcurse de la nodul S la nodul i.
    void bfs(int node,vector<int> visited, vector<int>& cost);

    void dfs(int node,vector<int>& visited,int nrcomp);
    int nr_comp_conexe(vector<int>& visited);
};

//constructorul
Graf::Graf(int mNodes, int mEdges, bool mIsDirected, bool mHaveCost) : m_nodes(mNodes), m_edges(mEdges),
                                                                       m_isDirected(mIsDirected),
                                                                       m_haveCost(mHaveCost) {
}

//adaugare muchii pentru orientat si neorientat
void Graf::add_Edge(int from, int to) {
    if(m_isDirected == 0) //este neorientat
    {
        adjList[from].push_back(to);
        adjList[to].push_back(from);
    }
    else //este orientat
        adjList[from].push_back(to);

}

void Graf::bfs(int node, vector<int> visited, vector<int>& cost) {
    int a;
    queue<int> q;
    visited.assign(m_nodes+1,0);
    cost.assign(m_nodes+1,-1);
    visited[node]=1;
    cost[node]=0;
    q.push(node);
    while(!q.empty()){
        node=q.front();
        a=cost[node];
        q.pop();
        for(auto i:adjList[node])
        {
            if(visited[i]==0){
                visited[i]=1;
                cost[i]=a+1;
                q.push(i);
            }
        }
    }

}

void Graf::dfs(int node, vector<int> &visited,int nrcomp) {
    int i;
    visited[node]=nrcomp;
    for(i=0;i<adjList[node].size();i++){
        if(!visited[adjList[node][i]]){
            dfs(adjList[node][i],visited,nrcomp);
        }
    }
}

int Graf::nr_comp_conexe(vector<int>& visited) {

    int nrcomp=0;
    for(int i=0;i<=m_nodes;i++)
    {
        visited.push_back(0);
    }

    for(int i=1;i<=m_nodes;i++)
    {
        if(visited[i]==0){
            nrcomp++;
            dfs(i,visited,nrcomp);
        }
    }
    return nrcomp;
}

void solve_bfs(){
    int n,m,S,x,y;
    f>>n>>m>>S;
    Graf graf(n,m,1,false);

    for(int i=0;i<m;++i)
    {
        f>>x>>y;
        graf.add_Edge(x,y);
    }
    vector<int> cost,visited;
    graf.bfs(S,visited,cost);
    for(int i=1;i<=n;i++)
        g<<cost[i]<<" ";
}


void solve_dfs_nrCompConexe(){
    int i,n,m,x,y,nrcomp=0;
    f>>n>>m;
    Graf graf(n,m,0,false);
    vector<int> visited;

    for(int i=0;i<m;++i)
    {
        f>>x>>y;
        graf.add_Edge(x,y);
    }
    g<<graf.nr_comp_conexe(visited);

}


int main() {

    //solve_bfs();
    solve_dfs_nrCompConexe();
    return 0;
}