Problem:
Score : 600 points

Problem Statement

Given is a tree T with N vertices. The i-th edge connects Vertex A_i and B_i (1 \leq A_i,B_i \leq N).

Now, each vertex is painted black with probability 1/2 and white with probability 1/2, which is chosen independently from other vertices. Then, let S be the smallest subtree (connected subgraph) of T containing all the vertices painted black. (If no vertex is painted black, S is the empty graph.)

Let the holeyness of S be the number of white vertices contained in S. Find the expected holeyness of S.

Since the answer is a rational number, we ask you to print it \bmod 10^9+7, as described in Notes.

Notes

When you print a rational number, first write it as a fraction \frac{y}{x}, where x, y are integers, and x is not divisible by 10^9 + 7
(under the constraints of the problem, such representation is always possible).

Then, you need to print the only integer z between 0 and 10^9 + 6, inclusive, that satisfies xz \equiv y \pmod{10^9 + 7}.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq A_i,B_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
A_1 B_1
:
A_{N-1} B_{N-1}

Output

Print the expected holeyness of S, \bmod 10^9+7.

Sample Input 1

3
1 2
2 3

Sample Output 1

125000001

If the vertices 1, 2, 3 are painted black, white, black, respectively, the holeyness of S is 1.

Otherwise, the holeyness is 0, so the expected holeyness is 1/8.

Since 8 \times 125000001 \equiv 1 \pmod{10^9+7}, we should print 125000001.

Sample Input 2

4
1 2
2 3
3 4

Sample Output 2

375000003

The expected holeyness is 3/8.

Since 8 \times 375000003 \equiv 3 \pmod{10^9+7}, we should print 375000003.

Sample Input 3

4
1 2
1 3
1 4

Sample Output 3

250000002

The expected holeyness is 1/4.

Sample Input 4

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

Sample Output 4

570312505

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.ABC_149
{
    class F
    {
        static void Main(string[] args)
        {
            var sw = new System.IO.StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);

            Method(args);

            Out.Flush();
        }

        static void Method(string[] args)
        {
            long n=ReadLong();
            List<int>[] edges = new List<int>[n];
            for (int i = 0; i < n; i++) edges[i] = new List<int>();
            for(int i = 0; i < n - 1; i++)
            {
                int[] ab = ReadInts();
                int a = ab[0]-1;
                int b = ab[1]-1;
                edges[a].Add(b);
                edges[b].Add(a);
            }
            long mask = 1000000000 + 7;
            long[] exps = new long[n + 5];
            exps[0] = 1;
            for(int i = 1; i < exps.Length; i++)
            {
                exps[i] = exps[i - 1] * 2;
                exps[i] %= mask;
            }
            int[] childCnts = new int[n];
            int[] parents = new int[n];
            DFS(childCnts, edges, parents, 0, -1);

            long res = 0;
            for(int i = 0; i < n; i++)
            {
                long tmp = 1;
                for(int j = 0; j < edges[i].Count; j++)
                {
                    if (edges[i][j] == parents[i])
                    {
                        tmp += exps[n - childCnts[i]] + mask - 1;
                    }
                    else
                    {
                        tmp += exps[childCnts[edges[i][j]]] + mask - 1;
                    }
                    tmp %= mask;
                }
                tmp = exps[n - 1] - tmp + mask;
                tmp %= mask;
                res += tmp;
            }
            res = Multi(res, Reverse(exps[n], mask - 2, mask), mask);
            WriteLine(res);
        }

        static long Multi(long a, long b,long mask)
        {
            return ((a % mask) * (b % mask)) % mask;
        }

        static long Reverse(long a, long pow, long mask)
        {
            if (pow == 0) return 1;
            else if (pow == 1) return a % mask;
            else
            {
                long halfMod = Reverse(a, pow / 2, mask);
                long nextMod = Multi(halfMod, halfMod, mask);
                if (pow % 2 == 0)
                {
                    return nextMod;
                }
                else
                {
                    return Multi(nextMod, a, mask);
                }
            }
        }

        static int DFS(int[] childCnts, List<int>[] edges,int[] parents,
            int now, int prev)
        {
            parents[now] = prev;
            if (prev >= 0 && edges[now].Count == 0)
            {
                childCnts[now] = 1;
            }
            else
            {
                int res = 1;
                for (int i = 0; i < edges[now].Count; i++)
                {
                    if (edges[now][i] == prev) continue;

                    res += DFS(childCnts, edges,parents, edges[now][i], now);
                }
                childCnts[now] = res;
            }
            return childCnts[now];
        }



        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}