#ifndef _ALGORITHM_H
#define _ALGORITHM_H
#include <fstream>
using namespace std;

/**
	Algorithm abstract class
	specifies protocol
*/
template<class I, class O>
class Algorithm
{
protected:

	I &in;
	O &out;

	/**
		algorithm method
		instantiates i/o
	*/
	Algorithm(I &, O &);
};

/**
	algorithm method
	instantiates i/o
*/
template<class I, class O>
Algorithm<I, O>::Algorithm(I &inp, O &outp): in(inp), out(outp)
{

}

#endif

#ifndef _CONNECTIVITY_H
#define _CONNECTIVITY_H

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

/**
	Connectivity class
	solves the connectivity in a graph problem
*/
class Connectivity: public Algorithm< vector<int>, vector<int> >
{
	int N, K;
	vector< vector<int> > Deg;
	vector<int> Vis;
	queue<int> Que;

public:

	/**
		maxflow method
		runs algorithm
	*/
	Connectivity(vector<int> &, vector<int> &);

private:

	/**
		read method
		reads input
	*/
	void Read();

	/**
		solve method
		solves problem
	*/
	void Solve();

	/**
		write method
		writes output
	*/
	void Write();

	/**
		bfs method
		computes connectivity
	*/
	void BFS(int);
};

#endif

/**
	connectivity method
	runs algorithm
*/
Connectivity::Connectivity(vector<int> &in, vector<int> &out): Algorithm< vector<int>, vector<int> >(in, out), N(0), K(0)
{
	Read();
	Solve();
	Write();
}

/**
	read method
	reads input
*/
void Connectivity::Read()
{
	int x, y, c, m;
	vector<int> Aux1;

	N = in[0];
	m = in[1];

	for (c = 0; c <= N; ++c)
	{
		Deg.push_back(Aux1);
	}
		
	for (c = 0; c < m; ++c)
	{
		x = in[c * 2 + 2];
		y = in[c * 2 + 3];
		Deg[x].push_back(y);
		Deg[y].push_back(x);
	}
}

/**
	solve method
	solves problem
*/
void Connectivity::Solve()
{
	Vis.assign(N + 1, 0);

	for (int i = 1; i <= N; ++i)
	{
		if (!Vis[i])
		{
			++K;
			BFS(i);
		}
	}
}

/**
	write method
	writes output
*/
void Connectivity::Write()
{
	out.push_back(K);

	for (int i = 1; i <= N; ++i)
	{
		out.push_back(Vis[i]);
	}
}

/**
	flow method
	computes flow
*/
void Connectivity::BFS(int x)
{
	int u, v;

	Vis[x] = K;
	Que.push(x);

	while (!Que.empty())
	{
		u = Que.front();
		Que.pop();

		for (vector<int>::iterator i = Deg[u].begin(); i != Deg[u].end(); ++i)
		{
			v = *i;

			if (!Vis[v])
			{
				Vis[v] = K;
				Que.push(v);
			}
		}
	}
}






int main()
{
	ifstream fin("dfs.in");
	ofstream fout("dfs.out");
	int N, M, x, y;

	vector<int> I;
	vector<int> O;

	fin >> N >> M;
	I.push_back(N);
	I.push_back(M);

	while (M--)
	{
		fin >> x >> y;
		I.push_back(x);
		I.push_back(y);
	}

	Connectivity mflow(I, O);

	fout << O[0] << '\n';

	fin.close();
	fout.close();
	return 0;
}