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 Ruby (2.7.1) (judge verdict: Wrong Answer)

#N = gets.to_i               # 単一整数
#a = gets.split.map(&:to_i)  # スペースで区切られた複数の整数
#a = N.times.map{gets.to_i}  # 縦に並んだ複数の整数。たまにある
#S = gets.chomp              # 文字列。chompを付けないと改行文字がついてくる

=begin
def solveABC177A
  D,T,S = gets.split.map(&:to_f)
  if D/S <= T 
    puts "Yes"
  else
    puts "No"
  end
end

def solveABC177B
  S = gets.chomp
  T = gets.chomp
  s_len = S.length
  t_len = T.length
  max_count = 0
  for i in 0..(s_len - t_len)
    match_count = 0
    extracted_str = S[i,t_len]
    for i2 in 0..(t_len-1)
      if extracted_str[i2] == T[i2]
        match_count += 1
      end
    end
    max_count = [match_count,max_count].max
  end
  puts t_len - max_count
end
=end

=begin
N = gets.to_i
An = gets.split.map(&:to_i)
Sn = [An[0]]
ans = 0
for i in 1..(An.length-1)
  Sn.push Sn[i-1] + An[i]
end

for i in 0..(An.length-1-1)
  ans += (An[i] * (Sn[N-1] - Sn[i])) % (10**9 + 7)
  ans %= (10**9 + 7)
end

puts ans
=end

N,M = gets.split.map(&:to_i)
$tree = []
for i in 0..(N-1)
  $tree.push []
end

for i in 0..(M-1)
  A,B = gets.split.map(&:to_i).sort
  $tree[A-1].push B-1
  puts "i is #{i}"
end

$used_nums = [-1]*N # nil is non used

def search(start_number,next_number)
  if $used_nums[next_number] != -1
    return
  end
  if start_number == next_number
    $used_nums[next_number] = next_number
  end
  for n in $tree[next_number]
    $used_nums[n] = start_number
    search(start_number,n)
  end
end

for i in 0..(N-1)  
  search(i,i)
end

max_count = [0]*N
for used_num in $used_nums
  max_count[used_num] += 1
end
puts max_count.max