Problem:
Score : 400 points

Problem Statement

There are N persons called Person 1 through Person N.

You are given M facts that "Person A_i and Person B_i are friends." The same fact may be given multiple times.

If X and Y are friends, and Y and Z are friends, then X and Z are also friends. There is no friendship that cannot be derived from the M given facts.

Takahashi the evil wants to divide the N persons into some number of groups so that every person has no friend in his/her group.

At least how many groups does he need to make?

Constraints

2 \leq N \leq 2\times 10^5

0 \leq M \leq 2\times 10^5

1\leq A_i,B_i\leq N

A_i \neq B_i

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
\vdots
A_M B_M

Output

Print the answer.

Sample Input 1

5 3
1 2
3 4
5 1

Sample Output 1

3

Dividing them into three groups such as \{1,3\}, \{2,4\}, and \{5\} achieves the goal.

Sample Input 2

4 10
1 2
2 1
1 2
2 1
1 2
1 3
1 4
2 3
2 4
3 4

Sample Output 2

4

Sample Input 3

10 4
3 1
4 1
5 9
2 6

Sample Output 3

3

Solution in Java (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.io.*;
import java.util.*;

 
public class Main{
	static class FastReader{
        BufferedReader br,br1;
        StringTokenizer st;
        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
        public FastReader(String fileName) throws FileNotFoundException{br = new BufferedReader(new FileReader(fileName));}
        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());}catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
        int nextInt(){return Integer.parseInt(next());}
        long nextLong(){return Long.parseLong(next());}
        double nextDouble(){return Double.parseDouble(next());}
        char[][] readCharArray(int n,int m) {
        	String str;
        	char[][] arr = new char[n][m];
        	for(int i=0;i<n;i++) {
        		str=nextLine();
        		for(int j=0;j<n;j++) {
        			arr[i][j]=str.charAt(j);
        		}
        	}
        	return arr;
        }
        char[][] readCharArray(int n){
        	return readCharArray(n,n);
        }
        int[] readArray(int n){int[] a=new int[n];for (int i=0; i<n; i++) a[i]=nextInt();return a;}
        long[] readLongArray(int n){long[] a=new long[n];for (int i=0; i<n; i++) a[i]=nextLong();return a;}
        String nextLine(){String str = "";try{str = br.readLine();}catch (IOException e){e.printStackTrace();}return str;}
    }
    static final Random random=new Random();
    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }
    static ArrayList<ArrayList<Integer>> arr;
	static boolean[] vis;
    static void addEdge(int n,int m) {
		if(!arr.get(n-1).contains(m-1)) arr.get(n-1).add(m-1);
		if(!arr.get(m-1).contains(n-1)) arr.get(m-1).add(n-1);
	}
    public static void main(String[] args) throws NumberFormatException, IOException {
    	//long time = System.currentTimeMillis();
    	FastReader st = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int n = st.nextInt();
        int m = st.nextInt();
        int temp,len,ele;
        arr = new ArrayList<ArrayList<Integer>>(n);
        vis = new boolean[n];
        for(int i=0;i<n;i++) arr.add(new ArrayList<Integer>());
        for(int i=0;i<m;i++) addEdge(st.nextInt(),st.nextInt());
        Stack<Integer> s = new Stack<Integer>();
        int count=1,ans=0;
        for(int j=0;j<n;j++) {
        	if(!vis[j]) {
        		vis[j]=true;
        		s.push(j);
            	count=1;
            	while(s.size()!=0) {
            		temp = s.pop();
            		len = arr.get(temp).size();
            		for(int i=0;i<len;i++) {
                		ele = arr.get(temp).get(i);
            			if(!vis[ele]) {
            				vis[ele]=true;
            				count++;
            				s.push(ele);
            			}
            		}
            	}
            	ans = Math.max(ans, count);
        	}
        }
        out.println(ans);
        out.close();
        //System.err.println(System.currentTimeMillis()-time);
    }
}