Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem B:
RabbitWalking

うさぎの住んでいる都市には, $V$ 個の交差点と $E$ 本の道がある. 交差点は 1-indexed で番号が付けられている. $i$ 番目の道は交差点 $a_i$ と交差点 $b_i$ を bidirectional につないでいる.

うさぎは, 散歩と奇数が好きである．うさぎはある交差点から出発し, 道を奇数本辿り, 出発した頂点に戻るような経路に沿って散歩したいと思っている．

この都市の市長であるねこは, 都市内の移動を効率化するために異なる2 つの交差点を結ぶ道をたくさん追加しようとしている．ただし，ある交差点の組に対して敷設することが出来る道は高々1本までである．また， ねこはいたずら好きなので，道を奇数本辿り, 出発した頂点に戻るような経路が含まれないようにしたいと思っている．

最大で何本道を付け加えられるか求めよ. ただし，最初からうさぎの要求が満たされている場合は-1 を出力せよ.

Constraints

$V$ will be between 1 and 100,000, inclusive.

$E$ will be between 0 and 100,000, inclusive.

$a_i$ and $b_i$ will be distinct.

No two roads connect the same pair of intersections.

Input

入力は以下の形式で与えられる:

$V$ $E$

$a_1$ $b_1$

...

$a_E$ $b_E$

Output

道を追加できる本数の最大値を表す整数を 1 行に出力せよ. 最初からうさぎの要求が満たされている場合は -1 を出力せよ.

Sample Input 1

8 5
1 2
6 5
6 4
1 3
4 7

Sample Output 1

11

Sample Input 2

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

Sample Output 2

-1

Solution in Ruby (judge verdict: Runtime Error)

module Graphical
	require 'set'

	def get_path_by_bfs(s, t)
		prev_node = {}
		reached = Set[s]
		queue = [s]
		while !queue.empty? 
			u = queue.shift
			each_out_connection_of(u){|v, _|
				next if reached.include?(v)	
				reached << v
				queue << v
				prev_node[v] = u

				if v == t
					path = [v]
					while v = prev_node[v]
						path.unshift v
					end
					return path
				end
			}
		end	
		return nil
	end

	def get_path_by_dfs(s, t, reached = Set.new)
		reached << s
		return [s] if s == t
		each_out_connection_of(s){|v|
			next if reached.include?(v)
			path = get_path_by_dfs(v, t, reached) 
			return [s] + path if path
		}
		nil
	end

	def reachable_from(s, max_depth = nil)
		reached = Set[s]
		queue = [s]
		depth = 0
		loop {
			break if max_depth && depth >= max_depth
			next_queue = []
			until queue.empty?
				u = queue.shift
				each_out_connection_of(u){|v, _|
					next if reached.include?(v)
					reached << v
					next_queue << v
				}
			end
			break if next_queue.empty?
			queue = next_queue
			depth += 1
		}
		return reached
	end

	def bfs(start)
		raise "start must be Enumerable" if !start.kind_of?(Enumerable)
		reached = Set[*start.to_a]
		queue = []
		start.each{|s| queue << s}
		dist = {}
		loop.with_index {|_, depth|
			next_queue = []
			until queue.empty?
				u = queue.shift
				return depth if block_given? && yield(u, depth)
				dist[u] = depth
				each_out_connection_of(u){|v, _|
					next if reached.include?(v)
					reached << v
					next_queue << v
				}
			end
			break if next_queue.empty?
			queue = next_queue
		}
		block_given? ? nil : dist
	end

	def dijkstra(start)
		raise "start must be Enumerable" if !start.kind_of?(Enumerable)
		h = Heap.new
		reached = Set[*start.to_a]
		start.each{|s| h.add(s, 0)}

		dist = {}
		until h.empty?
			u, key = h.del_min
			return key if block_given? && yield(u, key)
			dist[u] = key
			each_out_connection_of(u){|v, l|
				d = dist[u] + l
				if reached.include?(v)
					h.update_key(v, d)
				else
					h.add(v, d)
					reached << v
				end
			}
		end
		block_given? ? nil : dist
	end

	def bidir_dijkstra(s, t)
		f_dist = {}
		b_dist = {}

		f_heap = Heap.new
		b_heap = Heap.new

		f_heap.add(s, 0)
		b_heap.add(t, 0)

		f_reached = Set[s]
		b_reached = Set[t]

		f_current_dist = b_current_dist = 0
		best = Float::INFINITY

		loop {
			if !f_heap.empty?
				u, key = f_heap.del_min
				f_dist[u] = key
				f_current_dist = key
				each_out_connection_of(u){|v, l|
					d = f_dist[u] + l
					if b_dist[v]
						path_len = d + b_dist[v]
						best = path_len if path_len < best
					end
					if f_reached.include?(v)
						f_heap.update_key(v, d)
					else
						f_heap.add(v, d)
						f_reached << v
					end
				}
			end

			if !b_heap.empty?
				u, key = b_heap.del_min
				b_dist[u] = key
				b_current_dist = key
				each_in_connection_of(u){|v, l|
					d = b_dist[u] + l
					if f_dist[v]
						path_len = d + f_dist[v]
						best = path_len if path_len < best
					end
					if b_reached.include?(v)
						b_heap.update_key(v, d)
					else
						b_heap.add(v, d)
						b_reached << v
					end
				}
			end

			return best if f_current_dist + b_current_dist >= best
			return nil if f_heap.empty? && b_heap.empty?
		}
	end

	def a_star(start)
		raise "a_star need termination condition" unless block_given?
		h = Heap.new
		reached = Set[start]
		h.add(start, [a_star_heuristic(start), 0])

		dist = {}
		until h.empty?
			u, (e, d) = h.del_min
			return d if yield(u, dist)
			dist[u] = d
			each_out_connection_of(u){|v, l|
				d = dist[u] + l
				e = d + a_star_heuristic(v)
				if reached.include?(v)
					h.update_key(v, [e, d])
				else
					h.add(v, [e, d])
					reached << v
				end
			}
		end
		block_given? ? nil : dist
	end

	#make_variations :bidir_dijkstra

	def prim(start)
		h = Heap.new
		h.add(start, 0)
		reached = Set[start]
		tree_len = 0

		until h.empty?
			u, key = h.del_min
			tree_len += key

			each_out_connection_of(u){|v, d|
				if reached.include?(v)
					h.update_key(v, d)
				else
					h.add(v, d)
					reached << v
				end
			}
		end
		tree_len
	end

	def each_layer_from(start)
		raise "start must be Enumerable" if !start.kind_of?(Enumerable)
		return enum_for(__method__, start) unless block_given?
		reached = Set[*start]
		current_layer = start

		loop {
			yield current_layer
			next_layer = []
			current_layer.each{|u|
				each_out_connection_of(u){|v|
					next if reached.include?(v)
					reached << v
					next_layer << v
				}
			}	

			return if next_layer.empty?
			current_layer = next_layer
		}
	end
end

class Graph
	include Graphical

	def initialize(*options)
		@options = Set[*options]
	end

	def add_node(property = {})
		Node.new(property)
	end

	def add_edge(u, v, property = {})
		e = Edge.new(u, v, property)
		u.add_edge(e)
		v.add_edge(e)
		e
	end
	
	def del_edge(e)
		u, v = e.opposite.keys
		u.del_edge(e)
		v.del_edge(e)
		e
	end

	class Node
		def initialize(property)
			@property = property
			@edges = Set.new
		end

		def add_edge(e)
			@edges << e
		end

		def del_edge(e)
			@edges.delete(e)
		end

		def to_s
			@property[:name] || super
		end

		def each_edge
			@edges.each{|e| 
				yield e
			}
		end

		attr_reader :property
	end

	class Edge
		def initialize(u, v, property)
			@opposite = {u => v, v => u}
			@property = property
		end
		attr_reader :opposite, :property

		def to_s
			@property[:name] || super
		end

		def length
			@property[:length] || 1
		end
	end

	def each_out_connection_of(u)
		u.each_edge{|e|
			yield(e.opposite[u], e.length)
		}
	end

	alias :each_in_connection_of :each_out_connection_of
end

class Knapsack
	def initialize(items, budget)
		@items = items
		@budget = budget
		@states = []
	end

	def solve
		@items = @items.sort_by{|c, v| -v.to_f / c}
		@left_value = 0
		@left_cost = 0
		i = 0
		while i < @items.size
			c, v = @items[i]
			break if @left_cost + c > @budget
			@left_cost += c
			@left_value += v
			i += 1
		end

		@l = @r = i
		@lower_bound = @left_value

		return @left_value if @left_cost == @budget || @l == @items.size

		@states << [@left_cost, @left_value]
		@states << [@left_cost + @items[@l][0], @left_value + @items[@l][1]]
	
		loop {
			if @r < @items.size - 1
				@r += 1
				added = @items[@r]
				@states += @states.map{|c, v| [c + added[0], v + added[1]]}
				update_lower_bound
				prun
				break if @states.empty?
			end
	
			if @l > 0
				@l -= 1
				removed = @items[@l]
				@left_cost -= removed[0]
				@left_value -= removed[1]
				@states += @states.map{|c, v| [c - removed[0], v - removed[1]]}
				update_lower_bound
				prun
				break if @states.empty?
			end

		}
	
		return @lower_bound
	end

private
	def upper_bound(cost, value)
		if cost <= @budget
			@r == @items.size-1 ?
			value : value + (@budget - cost).to_f * @items[@r+1][1] / @items[@r+1][0] else
			@l == 0 ?
			value :
			value + (@budget - cost).to_f * @items[@l-1][1] / @items[@l-1][0]
		end
	end

	def prun
		@states.reject!{|c, v|
			next true if c - @left_cost > @budget
			next true if upper_bound(c, v) < @lower_bound+1
			false
		}
		hash = Hash.new(0)
		@states.each{|c, v|
			hash[c] = v if v > hash[c]
		}
		@states = hash.to_a
	end

	def update_lower_bound
		@states.each{|c, v|	
			@lower_bound = v if c <= @budget && v > @lower_bound
		}
	end
end

def knapsack_core(items, budget)
	k = Knapsack.new(items, budget)
	k.solve
end

def knapsack(items, budget)
	table = (0..1).map{ Array.new(budget+1, 0) }
	for i in 0..items.size-1
		p i
		c, v = items[i]
		for j in 0..budget
			x = table[0][j]
			y = (j >= c ? table[0][j-c] + v : 0)
			table[1][j] = x > y ? x : y
		end
		table << table.shift
	end
	table[0][budget]
end

def knapsack_preprocess(items, budget)
	cost_group = items.group_by(&:first)
	items = cost_group.map{|c, group|
		group.sort_by(&:last).last(budget / c)
	}.inject([], &:+)
end

n, m = gets.split.map &:to_i

g = Graph.new
nodes = (0..n).map{g.add_node}
m.times {
	i, j = gets.split.map &:to_i
	g.add_edge(nodes[i], nodes[j])
}

diffs = []
color = {}

(1..n).each{|i|
	u = nodes[i]
	next if color[u]
	color[u] = 0
	count = [0, 0]

	queue = [u]
	until queue.empty?
		u = queue.shift
		c = color[u]
		count[c] += 1
		g.each_out_connection_of(u){|v|
			if color[v] == c
				puts -1
				exit
			end
			next if color[v] 
			color[v] = 1 - c
			queue << v
		}
	end
	diff = -count.sort.inject(:-)
	diffs << diff unless diff == 0
}

total = diffs.inject(:+)
items = diffs.map{|x| [x, x]}
d = total/2 - knapsack_core(items, total/2)
x = n / 2 - d
p x * (n - x) - m