#include <stdio.h>
#include <stdlib.h>

const char true  = 1;
const char false = 0;

void swap (int *N1, int *N2)
{ int aux = *N1; *N1 = *N2; *N2 = aux; }

/* IMPLEMENTATION OF EdgePair */

struct EdgePair {
	int edge1, edge2;
};

struct EdgePair make_EdgePair (int edge1, int edge2) {
	struct EdgePair ret;
	ret.edge1 = edge1;
	ret.edge2 = edge2;
	return ret;
}

/**************************************************/

/* IMPLEMENTATION OF Queue */

typedef int T;

typedef struct QueueNode {
	T val;
	struct QueueNode *below;
} QueueNode;

typedef QueueNode *Queue;

void Queue_push (Queue *q, T value)
{
	QueueNode *qnode;
	qnode = malloc( sizeof(QueueNode) );
	qnode->below = *q;
	qnode->val   = value;
	*q           = qnode;
}

T Queue_pop (Queue *q)
{
	QueueNode *below;
	T ret;
	if (*q == NULL) return (T)0;
	below = (*q)->below;
	ret   = (*q)->val;
	free(*q);
	*q = below;
	return ret;
}

char Queue_empty (Queue *q)
{ return *q==NULL?true:false; }

/**************************************************/

/* IMPLEMENTATION OF BitSet */

#define MAX_BITSET_BYTES 12500

typedef char Bitset[MAX_BITSET_BYTES];

void Bitset_init (Bitset bitset)
{ memset(bitset, 0, MAX_BITSET_BYTES); }

void Bitset_set (Bitset bitset, int idx)
{ bitset[idx/8] |= 1<<(7-idx%8); }

void Bitset_reset (Bitset bitset, int idx)
{ bitset[idx/8] &= ~(1<<(7-idx%8)); }

char Bitset_test (Bitset bitset, int idx)
{ int pow2 = 1<<(7-idx%8); return (bitset[idx/8]&pow2) ? true : false; }
/**************************************************/

int main (void)
{
	
	int numVertices, numEdges, edge1, edge2, edge, uncheckedVertice, numGraphs=0;
	Queue Q;
	struct EdgePair edgepairs[200000];
	Bitset wasFound;
	freopen("dfs.in", "r", stdin);
	freopen("dfs.out", "w+", stdout);
	
	scanf("%d %d", &numVertices, &numEdges);
	
	for (edge=0; edge<numEdges; ++edge) {
		scanf("%d %d", &edge1, &edge2);
		if (edge1 > edge2) swap(&edge1, &edge2);
		edgepairs[edge] = make_EdgePair(edge1, edge2);
	}
	
	Bitset_init(wasFound);
	uncheckedVertice = 1;
	
	do {
		//printf("Graf nou (%d).\n", uncheckedVertice);
		++numGraphs;
		Queue_push(&Q, uncheckedVertice);
		while (Queue_empty(&Q) == false) {
			int vertice = Queue_pop(&Q);
			//printf("Gasit vertice %d in graf\n", vertice);
			Bitset_set(wasFound, vertice);
			for (edge=0; edge<numEdges; ++edge)
				if (edgepairs[edge].edge1 == vertice || edgepairs[edge].edge2 == vertice) {
					int relatedVertice = edgepairs[edge].edge1==vertice ?
						edgepairs[edge].edge2 : edgepairs[edge].edge1;
					if (!Bitset_test(wasFound, relatedVertice)) Queue_push(&Q, relatedVertice);
				}
		}
		for (uncheckedVertice=2; uncheckedVertice<=numVertices
				&& Bitset_test(wasFound,uncheckedVertice); ++uncheckedVertice);
	} while (uncheckedVertice <= numVertices);
	
	printf("%d\n", numGraphs);
	fclose(stdin);
	fclose(stdout);
	return 0;
}