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 Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_parens)]
#![allow(unused_imports)]
#![allow(non_upper_case_globals)]
#![allow(non_snake_case)]
#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(dead_code)]

use itertools::Itertools;
use proconio::input;
use proconio::marker::{Chars, Usize1};

#[allow(unused_macros)]
#[cfg(debug_assertions)]
macro_rules! mydbg {
    //($arg:expr) => (dbg!($arg))
    //($arg:expr) => (println!("{:?}",$arg));
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
      }
}
#[cfg(not(debug_assertions))]
macro_rules! mydbg {
    ($($arg:expr),*) => {};
}

macro_rules! echo {
    ($($a:expr),*) => {
          $(println!("{}",$a))*
      }
}

use std::cmp::*;
use std::collections::*;
use std::ops::{Add, Div, Mul, Sub};

#[allow(dead_code)]
static INF_I64: i64 = 92233720368547758;
#[allow(dead_code)]
static INF_I32: i32 = 21474836;
#[allow(dead_code)]
static INF_USIZE: usize = 18446744073709551;
#[allow(dead_code)]
static M_O_D: usize = 1000000007;
#[allow(dead_code)]
static PAI: f64 = 3.1415926535897932;

trait IteratorExt: Iterator {
    fn toVec(self) -> Vec<Self::Item>;
}

impl<T: Iterator> IteratorExt for T {
    fn toVec(self) -> Vec<Self::Item> {
        self.collect()
    }
}

trait CharExt {
    fn toNum(&self) -> usize;
    fn toAlphabetIndex(&self) -> usize;
    fn toNumIndex(&self) -> usize;
}
impl CharExt for char {
    fn toNum(&self) -> usize {
        return *self as usize;
    }
    fn toAlphabetIndex(&self) -> usize {
        return self.toNum() - 'a' as usize;
    }
    fn toNumIndex(&self) -> usize {
        return self.toNum() - '0' as usize;
    }
}

trait VectorExt {
    fn joinToString(&self, s: &str) -> String;
}
impl<T: ToString> VectorExt for Vec<T> {
    fn joinToString(&self, s: &str) -> String {
        return self
            .iter()
            .map(|x| x.to_string())
            .collect::<Vec<_>>()
            .join(s);
    }
}

trait StringExt {
    fn get_reverse(&self) -> String;
}
impl StringExt for String {
    fn get_reverse(&self) -> String {
        self.chars().rev().collect::<String>()
    }
}

trait UsizeExt {
    fn pow(&self, n: usize) -> usize;
}
impl UsizeExt for usize {
    fn pow(&self, n: usize) -> usize {
        return ((*self as u64).pow(n as u32)) as usize;
    }
}

pub struct UnionFind {
    parent: Vec<i32>,
}
impl UnionFind {
    pub fn new(n: usize) -> Self {
        UnionFind {
            parent: vec![-1; n],
        }
    }
    pub fn root(&mut self, a: i32) -> i32 {
        if self.parent[a as usize] < 0 {
            return a;
        } else {
            let index = self.parent[a as usize];
            self.parent[a as usize] = self.root(index);
            return self.parent[a as usize];
        }
    }
    pub fn rank(&mut self, a: i32) -> i32 {
        let tmp = self.root(a);
        return -1 * self.parent[tmp as usize];
    }
    pub fn ranks(&mut self, ret: &mut Vec<i32>) -> bool {
        for item in self.parent.iter().filter(|&x| *x < 0) {
            ret.push(item.clone());
        }
        return true;
    }
    pub fn join(&mut self, a: i32, b: i32) -> bool {
        let mut a_root = self.root(a);
        let mut b_root = self.root(b);
        if (a_root == b_root) {
            return false;
        }
        if (self.rank(b_root) > self.rank(a_root)) {
            std::mem::swap(&mut a_root, &mut b_root);
        }
        self.parent[a_root as usize] += self.parent[b_root as usize];
        self.parent[b_root as usize] = a_root;
        return true;
    }
}

fn main() {
    input! {
       N: usize,
       M:usize,
    }

    let mut uf = UnionFind::new(N);
    for _ in 0..M {
        input! {
            a:Usize1,
            b:Usize1,
        }
        uf.join(a as i32, b as i32);
    }

    let mut s = vec![0; N];
    for i in 0..N {
        let b = uf.root(i as i32);
        s[b as usize] += 1;
    }
    let mut ans: usize = *s.iter().max().unwrap();

    echo!(ans);
}