Problem:
Score : 500 points

Problem Statement

There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.

Let A_i be the integer written on the i-th card.

Your objective is to guess A_1, A_2, ..., A_N correctly.

You know the following facts:

For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.

You are a magician and can use the following magic any number of times:

Magic: Choose one card and know the integer A_i written on it. The cost of using this magic is 1.

What is the minimum cost required to determine all of A_1, A_2, ..., A_N?

It is guaranteed that there is no contradiction in given input.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq X_i < Y_i \leq N

1 \leq Z_i \leq 100

The pairs (X_i, Y_i) are distinct.

There is no contradiction in input. (That is, there exist integers A_1, A_2, ..., A_N that satisfy the conditions.)

Input

Input is given from Standard Input in the following format:

N M
X_1 Y_1 Z_1
X_2 Y_2 Z_2
\vdots
X_M Y_M Z_M

Output

Print the minimum total cost required to determine all of A_1, A_2, ..., A_N.

Sample Input 1

3 1
1 2 1

Sample Output 1

2

You can determine all of A_1, A_2, A_3 by using the magic for the first and third cards.

Sample Input 2

6 5
1 2 1
2 3 2
1 3 3
4 5 4
5 6 5

Sample Output 2

2

Sample Input 3

100000 1
1 100000 100

Sample Output 3

99999

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main{
  public static void main(String args[]){
    int n, m;
    ArrayList<Integer> x = new ArrayList<Integer>();
    ArrayList<Integer> y = new ArrayList<Integer>();
    ArrayList<Integer> aList = new ArrayList<Integer>();
    int result = 0;
    try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String str = reader.readLine();
        String[] nums = str.split(" ");
        n = Integer.parseInt(nums[0]);
        m = Integer.parseInt(nums[1]);
        String str2;
        while((str2 = reader.readLine())!=null){
            String[] nums2 = str2.split(" ");
            x.add(Integer.parseInt(nums2[0]));
            y.add(Integer.parseInt(nums2[1]));
        }

        int input[][] = new int[m][3];

        for(int i = 0; i < m; i++){
          input[i][0] = x.get(i);
          input[i][1] = y.get(i);
          input[i][2] = 1;
        }

        for(int i = 0; i < m; i++){
          if(check(aList,input[i][0])){
			if(!check(aList,input[i][1])){
            	aList.add(input[i][1]);
            }
          }else{
            result++;
            aList.add(input[i][0]);
          	for(int j = 0; j < m; j++){
            	if(input[i][0] == input[j][0]){
                	if(!check(aList,input[j][1])){
            			aList.add(input[j][1]);
            		}
                }
              
              	if(input[i][0] == input[j][1]){
                	if(!check(aList,input[j][0])){
            			aList.add(input[j][0]);
            		}
                }
            }
          }
          
          if(check(aList,input[i][1])){
			if(!check(aList,input[i][0])){
            	aList.add(input[i][0]);
            }
          }else{
            aList.add(input[i][1]);
            result++;
          	for(int j = 0; j < m; j++){
            	if(input[i][1] == input[j][0]){
                	if(!check(aList,input[j][1])){
            			aList.add(input[j][1]);
            		}
                }
              
              	if(input[i][1] == input[j][1]){
                	if(!check(aList,input[j][0])){
            			aList.add(input[j][0]);
            		}
                }
            }
          }
        }

      	result = result + n - aList.size();
        System.out.println(result);
    } catch (IOException e) {
                e.printStackTrace();
    }
  }
  
  static boolean check( ArrayList<Integer> aList, int num){
  	for(int p:aList){
      if(p==num){
        return true;
      }
    }
    return false;
  }
}