Problem:
Score : 500 points

Problem Statement

Rng has a connected undirected graph with N vertices.
Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.

Rng will add new edges to the graph by repeating the following operation:

Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.

Find the maximum possible number of edges that can be added.

Constraints

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq A_i,B_i \leq N

The graph has no self-loops or multiple edges.

The graph is connected.

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
:
A_M B_M

Output

Find the maximum possible number of edges that can be added.

Sample Input 1

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

Sample Output 1

4

If we add edges as shown below, four edges can be added, and no more.

Sample Input 2

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

Sample Output 2

5

Five edges can be added, for example, as follows:

Add an edge connecting Vertex 5 and Vertex 3.

Add an edge connecting Vertex 5 and Vertex 2.

Add an edge connecting Vertex 4 and Vertex 1.

Add an edge connecting Vertex 4 and Vertex 2.

Add an edge connecting Vertex 4 and Vertex 3.

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)


d = gets.chomp.split(" ").map(&:to_i)
HASH = Hash.new{|k,v| k[v] = []}
HASH2 = Hash.new{|k,v| k[v] = []}
ELAPSED = Array.new(d[0])
d[1].times do
  t = gets.chomp.split(" ").map(&:to_i)
  HASH[t[0]] << t[1]
  HASH[t[1]] << t[0]
end

if d[1] >= d[0]
  p (((d[0])*(d[0]-1))/2 - d[1])
exit
elsif d[1] < d[0]-1
  raise
end

def dfs2(current, times, prev)
  return current if times == 3
  list = []
  HASH[current].each do |t|
    list << dfs2(t, times+1, current) if t != prev
  end
  return list
end
def add_edges(t)
    count = 0
    dfs2(t, 0, 0).flatten.each do |s|
      unless s == -1 || t == s || HASH[t].include?(s) #|| HASH2[t].include?(s)
        count += 1
        HASH[t] << s
        HASH[s] << t
      end
    end
    return count
end

def dfs(current, times, prev)
  #return -1 if ELAPSED[current] == 1
  ELAPSED[current] = 1
  #return current if times == 3
  #return times if HASH[current]==[prev]
  return add_edges(current) if HASH[current]==[prev]
  list = []
  HASH[current].each do |t|
    list << dfs(t, times+1, current) if t != prev
  end
  return list
end

count = 0
(1..d[0]).each do |t|
  count += add_edges(t)
end
p count
exit

p = HASH.to_a.max{|a,b| a[1].size <=>b[1].size}[0]
k = dfs(p, 0, 0).flatten!
#p k
#p HASH2
if !k
  p 0
elsif k.include?(-1)
  p (((d[0])*(d[0]-1))/2 - d[1])
else
  dt = d[0]-3
  if dt == 0
  p 0
  else
  #p (dt*dt-dt+2)/2
  #p ((dt*dt - dt + 2)/ 2 + (d[0]-1) - d[1])
  p k.inject(:+)
  #p COUNT
  end
end