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

const int NMAX = numeric_limits<int>::max();


struct edge {
    int node, cost;
    edge(int node , int cost ) {
        this->node = node;
        this->cost = cost;
    }
};

/// add consts
class Graph {
protected:
    int nrNodes, nrEdges;
    bool oriented;
    vector<vector<int>> edges;
public:
    Graph( const int nrNodes, bool oriented = true) ;
    void addEdge(const int x,const int y); // sets edge between x and y
    int getNumberOfNodes();
    vector<int> BFS(int startingNode);
    vector<int> DFS(int node);
    int connectedComponents();  // returns the number of conencted components from the graph
    int getGraphDiameter();
    vector<int> getTopologicalSortedGraph();
    vector<vector<int>> stronglyConnectedComponents();   // outputs the strongly connected components
    vector<vector<int>> biconnectedComponents(); // returns the array of biconnected components
    vector<pair<int,int>> getCriticalConnections(); // return array of critical edge
    bool havelHakim(vector<int> grades); //  returns true or false if the grades array form a valid graph
    ~Graph();
private:
    void dfsAux(int node, vector<int>& visited);
    void topologicalSort(int x, vector<int> &visited, vector<int>& topoSort);
    void DFS_strongly_conn_comp(int currentNode, vector<int> &component, int currentComponent, vector<vector<int>> & solution, vector<vector<int>>& transposedGraph); // used in stronglyConnComponents
    void DFS_crit(int node, int predecesor, int level, vector<int>& lvl,vector<int>& low, vector<pair<int,int>>& output ); // used in getCriticalConnections
    void DFS_bcc(int node, int parent, int level, vector<int> &lvl, vector<int> &low, stack<int>& nodeStack,
                 vector<vector<int>> &output);

};
Graph::Graph(const int nrNodes, bool oriented) {
    this->nrNodes = nrNodes;
    this->oriented = oriented;
    edges.resize(nrNodes + 1);
}
void Graph::addEdge(const int x, const int y) {
    this->edges[x].push_back(y);
    if(!oriented) {
        this->edges[y].push_back(x);
    }
}
int Graph::getNumberOfNodes() {
    return this->nrNodes;
}
vector<int> Graph::BFS(int startingNode) {
    vector<int> distances(this->nrNodes + 1, -1);
    vector<int> visited(this->nrNodes+1, 0);
    queue<int> queue;

    distances[startingNode] = 0;
    visited[startingNode] = 1;
    queue.push(startingNode);

    while(!queue.empty()){
        int currentNode = queue.front();
        for(auto node : edges[currentNode]){
            if(!visited[node]){
                visited[node] = 1;
                distances[node] = distances[currentNode] + 1;
                queue.push(node);
            }
        }
        queue.pop();
    }
    return distances;
}
vector<int> Graph::DFS(int node) {
    vector<int> visited(nrNodes+1, 0);
    dfsAux(node, visited);
    return visited;
}
void Graph::dfsAux(int currentNode, vector<int> &visited) {
    for(auto node : this->edges[currentNode]) {
        if(!visited[node]) {
            visited[node] = 1;
            dfsAux(node, visited);
        }
    }

}
int Graph::connectedComponents() {
    int connectedComp = 0;
    vector<int>visited(this->nrNodes + 1, 0);
    for(int i = 1; i<= nrNodes; i++) {
        if(!visited[i]) {
            visited[i] = 1;
            connectedComp++;
            dfsAux(i,visited);
        }
    }
    return connectedComp;
}

int Graph::getGraphDiameter() {
    vector<int> distance = BFS(1); // bfs from endNode 1
    int maxDistance = -1;
    int endNode;
    for(int i = 1; i < distance.size(); i++) { // the maximum distance to a endNode
        if(distance[i] > maxDistance)
        {
            maxDistance = distance[i];
            endNode = i;
        }
    }
    maxDistance = -1;
    distance = BFS(endNode); // bfs from the endNode with the maximum distance
    for(int i = 1; i< distance.size(); i++) {
        if(distance[i] > maxDistance)
        {
            maxDistance = distance[i];
        }
    }
    return maxDistance;
}
void Graph::topologicalSort(int currentNode, vector<int> &visited, vector<int>& topoSort) {
    visited[currentNode] = 1;
    for(auto node: this->edges[currentNode]){
        if(!visited[node])
            topologicalSort(node, visited, topoSort);
    }
    topoSort.push_back(currentNode);
}
vector<int> Graph::getTopologicalSortedGraph() {
    vector<int> topoSort;
    vector<int>visited(this->nrNodes+1, 0);
    for(int i = 1; i<= nrNodes; i++){
        if(!visited[i])
            topologicalSort(i, visited, topoSort); // sort in topologcal order
    }
    return topoSort;
}
void Graph::DFS_strongly_conn_comp(int currentNode, vector<int> &visited, int currentComponent, vector<vector<int>> & solution, vector<vector<int>>& transposedGraph) { // dfs used for strongly conn comp
    visited[currentNode] = 1;
    solution[currentComponent].push_back(currentNode);
    for(auto i: transposedGraph[currentNode]){
        if(visited[i] == 0){
            DFS_strongly_conn_comp(i,visited,currentComponent,solution, transposedGraph);
        }
    }
}
vector<vector<int>> Graph::stronglyConnectedComponents(){
    vector<vector<int>>solution;
    vector<vector<int>> transposedGraph;
    transposedGraph.resize(this->nrNodes+1);
    for(int i = 1; i<= this->nrNodes; i++){             // compute transposed graph
        for(auto j : edges[i]){
            transposedGraph[j].push_back(i);
        }
    }

    vector<int> v = getTopologicalSortedGraph();
    stack<int> topoSort;

    for(auto i : v)
    {
        topoSort.push(i);
    }
    vector<int>visited2(this->nrNodes+1, 0);

    solution.push_back(vector<int>());
    int currentComponent = 0;
    while(!topoSort.empty()) {
        int i = topoSort.top();
        topoSort.pop();
        if(visited2[i] == 0) {
            currentComponent++;
            solution.push_back(vector<int>());
            DFS_strongly_conn_comp(i, visited2, currentComponent,solution, transposedGraph);
        }
    }
    return solution;
}
bool Graph::havelHakim(vector<int> grades) {
    sort(grades.begin(), grades.end(), greater<>());
    if(grades[0] > grades.size()-1)
        return false;
    while (true){
        int gr = grades[0];
        grades.erase(grades.begin());
        for(int& i: grades){
            gr--;
            i--;
            if(i < 0) return false;
            if(gr == 0) break;
        }
        sort(grades.begin(), grades.end(), greater<>());
        if(grades.empty() || grades[0] == 0){
            return true;
        }
    }
}

vector<pair<int,int>> Graph::getCriticalConnections() {
    vector<int> lvl(this->nrNodes+1, 0);
    vector<int> low(this->nrNodes+ 1, 1);
    vector<pair<int,int>> output(this->nrNodes+1);
    DFS_crit(1,-1,1,lvl, low,output);
    return output;

}
void Graph::DFS_crit(int node, int parent, int level, vector<int> &lvl, vector<int> &low,
                     vector<pair<int, int>> &output) {
    lvl[node] = level;
    low[node] = level;
    for(auto i : this->edges[node]){
        if(lvl[i] == 0) {
            DFS_crit(i,node, level+1, lvl, low, output);
            low[node] = min(low[node], low[i]);
        }
        else if(lvl[i] != 0 && i != parent)
            low[node] = min(low[node], lvl[i]);
    }
    if(low[node] == lvl[node] && node != 0){
        pair<int,int> edge;
        edge.first = node;
        edge.second = parent;
        output.push_back(edge);
    }

}
vector<vector<int>> Graph::biconnectedComponents() {
    vector<int> lvl(this->nrNodes+1, 0);
    vector<int> low(this->nrNodes+ 1, 0);
    vector<vector<int>> output;
    stack<int> nodeStack;
    int level = 1, parent = 0;
    for(int i = 1; i<= this->nrNodes; i++) {
        if(lvl[i] == 0) {
            DFS_bcc(i,parent, level,lvl,low,nodeStack,output);
        }
    }
    return output;
}
void Graph::DFS_bcc(int node, int parent, int level, vector<int> &lvl, vector<int> &low,stack<int>& nodeStack,
                    vector<vector<int>> &output) {
    lvl[node] = level;
    low[node] = level;
    nodeStack.push(node);
    for(auto i : this->edges[node]){
        if(lvl[i] == 0 ){
            DFS_bcc(i,node,level+1,lvl, low,nodeStack, output);
            low[node] =  min(low[node], low[i]);
            if(low[i] >= lvl[node]) {
                vector<int> biconnectedComponent;
                biconnectedComponent.push_back(node);
                while(nodeStack.top() != i ){
                    biconnectedComponent.push_back(nodeStack.top());
                    nodeStack.pop();
                }
                biconnectedComponent.push_back(i);
                nodeStack.pop();
                output.push_back(biconnectedComponent);
            }
        }
        else if(i != parent)
            low[node] = min(low[node], lvl[i]);
    }

}
Graph::~Graph(){
    edges.clear();
}
class WeightedGraph : public Graph
{
private:
    vector<vector<edge>> weigthedEdges;
public:
    WeightedGraph(const int nrNodes, bool oriented = true);
    void addEdge(const int x, const int y,const int cost);
    vector<int> Dijkstra (int node);
    vector<int> BellmanFord(int node);
    vector<int> Prim(int node, int& totalCost);
    void disjoint(vector<tuple<int,int,int>>, vector<int>& roots, ostream& g);

    vector<vector<edge>> FloydWarshall();
private:
    int findRoot(int node, vector<int> &roots);
};

WeightedGraph::WeightedGraph(const int nrNodes, bool oriented): Graph(nrNodes, oriented) {
    this->weigthedEdges.resize(nrNodes+1);
}

void WeightedGraph::addEdge(const int x,const int y,const int cost) {
    this->weigthedEdges[x].push_back(edge(y,cost));
    if(!oriented) {
        this->weigthedEdges[y].push_back(edge(x,cost));
    }
}

vector<int> WeightedGraph::Dijkstra(int node) {
    vector<int> minDistance(nrNodes+1,NMAX);
    vector<bool> visited(nrNodes+1, false);
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
    minDistance[node] = 0;
    pq.push(make_pair(0,node));
    while(!pq.empty()) {
        int current_node = pq.top().second;
        pq.pop();
        if(!visited[current_node]) {
            visited[current_node] = true;
            for(auto i: this->weigthedEdges[current_node]){
                if(minDistance[current_node] + i.cost < minDistance[i.node]){
                    minDistance[i.node] = minDistance[current_node] + i.cost;
                    pq.push(make_pair(minDistance[i.node], i.node));
                }
            }
        }
    }

    return minDistance;
}
vector<int> WeightedGraph::BellmanFord(int node) {
    vector<int> minDistances(nrNodes+1, NMAX);
    vector<int> visited(nrNodes+1, 0);
    vector<bool> inQueue(nrNodes + 1, false);
    queue<int> q;
    q.push(node);
    inQueue[node] = true;
    minDistances[node] = 0;
    while(!q.empty()){
        int current_node = q.front();
        visited[current_node]++;
        q.pop();
        inQueue[current_node] = false;
        if(visited[current_node] >= nrNodes)
            return {};
        for(auto i :this->weigthedEdges[current_node])
        {
            if(minDistances[current_node] + i.cost < minDistances[i.node]){
                minDistances[i.node] = minDistances[current_node] + i.cost;

                if(!inQueue[i.node]){
                    q.push(i.node);
                    inQueue[i.node] = true;
                }
            }
        }
    }
    return minDistances;
}

vector<int> WeightedGraph::Prim(int node, int &totalCost) {
    vector<int> minDistance(nrNodes+1, NMAX);
    vector<int> parent(nrNodes+1, 0);
    vector<bool> selected(nrNodes+1, false);
    priority_queue<pair<int, int>,vector<pair<int, int>> ,greater<>>pq;
    minDistance[node] = 0;
    pq.push(make_pair(0,1));
    while(!pq.empty())
    {
        int currentNode = pq.top().second;
        int currentCost = pq.top().first;
        pq.pop();
        if(!selected[currentNode])
        {
            selected[currentNode] = true;
            totalCost= totalCost + currentCost;
            for(auto i : this->weigthedEdges[currentNode]){
                if(!selected[i.node])
                {
                    if(i.cost < minDistance[i.node])
                    {
                        minDistance[i.node] = i.cost;
                        parent[i.node] = currentNode;
                        pq.push(make_pair(minDistance[i.node], i.node));
                    }
                }
            }
        }
    }
    return parent;
}

int WeightedGraph::findRoot(int node, vector<int>& roots) {
    if(roots[node] != node)
        return roots[node] = findRoot(roots[node], roots);
    return roots[node] ;
}

void WeightedGraph::disjoint(vector<tuple<int,int,int>> v, vector<int>& roots, ostream& g) {
    for(auto i : v) {
        int code = get<0>(i);
        int firstNode = get<1>(i);
        int secondNode = get<2>(i);
        if(code == 1) {
            int firstNodeRoot = findRoot(firstNode, roots);
            int secondNodeRoot = findRoot(secondNode, roots);
            roots[firstNodeRoot] = secondNodeRoot;  // append the root of the first tree to the root of the cost tree
        }
        else if (code == 2)
        {
            if(findRoot(firstNode, roots) == findRoot(secondNode, roots)){
                g << "DA\n";
            }
            else g << "NU\n";
        }
    }
}

vector<vector<edge>> WeightedGraph::FloydWarshall() {
    vector<vector<edge>> distances = this->weigthedEdges;
    for(int k = 0; k < this->nrNodes; k++)
        for(int i = 0; i< this->nrNodes; i++)
            for(int j = 0; j< this->nrNodes; j++) {
                if( i != j && distances[k][j].cost && distances[i][k].cost )
                    if(distances[i][j].cost > distances[i][k].cost + distances[k][j].cost || distances[i][j].cost == 0){
                        distances[i][j].cost = distances[i][k].cost + distances[k][j].cost;
                    }
            }
    return distances;
}
int main()
{
    int nrNodes, nrEdges;
    ifstream f("dfs.in");
    ofstream g("dfs.out");
    f >> nrNodes >> nrEdges;
    Graph G(nrNodes, false);
    int x,y;
    for(int i = 0; i < nrEdges; i++) {
            f >> x >> y;
            G.addEdge(x,y);
    }
    g << G.connectedComponents();
}