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

Similarity of Subtrees

Define the depth of a node in a rooted tree by applying the following rules recursively:

The depth of a root node is 0.

The depths of child nodes whose parents are with depth $d$ are $d + 1$.

Let $S(T, d)$ be the number of nodes of $T$ with depth $d$. Two rooted trees $T$ and $T'$ are similar if and only if $S(T, d)$ equals $S(T', d)$ for all non-negative integer $d$.

You are given a rooted tree $T$ with $N$ nodes. The nodes of $T$ are numbered from 1 to $N$. Node 1 is the root node of $T$. Let $T_i$ be the rooted subtree of $T$ whose root is node $i$. Your task is to write a program which calculates the number of pairs $(i, j)$ such that $T_i$ and $T_j$ are similar and $i < j$.

Input

The input consists of a single test case.

$N$

$a_1$ $b_1$

$a_2$ $b_2$

...

$a_{N-1}$ $b_{N-1}$

The first line contains an integer $N$ ($1 \leq N \leq 100,000$), which is the number of nodes in a tree. The following $N -1$ lines give information of branches: the $i$-th line of them contains $a_i$ and $b_i$, which indicates that a node $a_i$ is a parent of a node $b_i$. ($1 \leq a_i, b_i \leq N, a_i \ne b_i$) The root node is numbered by 1. It is guaranteed that a given graph is a rooted tree, i.e. there is exactly one parent for each node except the node 1, and the graph is connected.

Output

Print the number of the pairs $(x, y)$ of the nodes such that the subtree with the root $x$ and the subtree with the root $y$ are similar and $x < y$.

Sample Input 1

5
1 2
1 3
1 4
1 5

Output for the Sample Input 1

6

Sample Input 2

6
1 2
2 3
3 4
1 5
5 6

Output for the Sample Input 2

2

Sample Input 3

13
1 2
1 3
2 4
2 5
3 6
3 7
4 8
4 9
6 10
7 11
8 12
11 13

Output for the Sample Input 3

14

Solution in Ruby (judge verdict: Runtime Error)

class List
    def initialize(val)
        @val = val
        @next = nil
        @code = nil
    end

    def merge(other)
        return self if !other
        new_head = self.class.new(@val + other.val)
        if @next
            new_head.next = @next.merge(other.next)
        else
            new_head.next = other.next
        end
        new_head
    end

    def encode
        return @val.to_s if !@next
        @code ||= @val.to_s + "," + @next.encode
    end

    attr_accessor :next
    attr_reader :val
end

require 'tsort'

class Hash
    include TSort
    alias tsort_each_node each_key

    def tsort_each_child(u)
        self[u].each do |v|
            yield v
        end
    end
end

n = gets.to_i
g = {}
(1..n).map {|v| g[v] = []}

(n-1).times do
    u, v = gets.split.map(&:to_i)
    g[u] << v
end

head = {}
g.tsort.each do |u|
    l = List.new(1)
    if !g[u].empty?
        merged = g[u].map {|v| head[v]}.inject {|m, l| m.merge(l)}
        l.next = merged
    end
    head[u] = l
end

group = Hash.new(0)
(1..n).each do |u|
    group[head[u].encode] += 1
end
p group.each_value.map {|k| k * (k-1)/2}.inject(:+)