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 Rust (1.15.1) (judge verdict: Accepted)

use std::cell::Cell;

const MOD: i32 = 1000000007;

fn main() {
	let mut s = String::new();
	use std::io::Read;
	std::io::stdin().read_to_string(&mut s).unwrap();
	let mut s = s.split_whitespace();
	let n: usize = s.next().unwrap().parse().unwrap();
	let mut edges = vec![vec![]; n];
	for _ in 0..n - 1 {
		let a = s.next().unwrap().parse::<u32>().unwrap() - 1;
		let b = s.next().unwrap().parse::<u32>().unwrap() - 1;
		edges[a as usize].push(b);
		edges[b as usize].push(a);
	}
	let tree = Tree::new(edges);
	tree.dfs();
	let y = tree.calc();
	let x = mod_pow(tree.two_power[n] as i64, MOD as u32 - 2, MOD as i64);
	println!("{}", y as i64 * x % MOD as i64);
}

struct Tree {
	edges: Vec<Vec<u32>>,
	children: Vec<Cell<u32>>,
	parent: Vec<Cell<u32>>,
	two_power: Vec<i32>,
}

impl Tree {
	fn new(edges: Vec<Vec<u32>>) -> Tree {
		let n = edges.len();
		let pow: Vec<_> = (0..n + 1)
			.scan(1, |s, _| {
				let a = *s;
				*s = a * 2 % MOD;
				Some(a)
			})
			.collect();
		Tree { edges: edges, children: vec![Cell::new(0); n], parent: vec![Cell::new(0); n], two_power: pow }
	}

	fn dfs(&self) {
		let mut q1 = vec![(0, std::u32::MAX)];
		let mut q2 = vec![];
		while let Some(p) = q1.pop() {
			q2.push(p);
			for e in self.edges[p.0 as usize].iter() {
				if *e == p.1 {
					continue;
				}
				q1.push((*e, p.0));
			}
		}
		while let Some(p) = q2.pop() {
			let mut c = 0;
			self.parent[p.0 as usize].set(p.1 as u32);
			for e in self.edges[p.0 as usize].iter() {
				if *e == p.1 {
					continue;
				}
				c += self.children[*e as usize].get() + 1;
			}
			self.children[p.0 as usize].set(c);
		}
	}

	fn calc(&self) -> i32 {
		let n = self.edges.len();
		let mut r = 0;
		for i in 0..n {
			let mut csum = 0;
			let mut pat = 0;
			for e in self.edges[i].iter() {
				if *e == self.parent[i].get() {
					continue;
				}
				let c = self.children[*e as usize].get() + 1;
				pat = (pat + self.two_power[c as usize] - 1) % MOD;
				csum += c;
			}
			pat = (pat + self.two_power[n - 1 - csum as usize] - 1 + 1) % MOD;
			pat = (self.two_power[n - 1] + MOD - pat) % MOD;
			r = (r + pat) % MOD;
		}
		r
	}
}

fn mod_pow(a: i64, n: u32, m: i64) -> i64 {
	let mut r = 1;
	let mut a = a;
	let mut n = n;
	while n > 0 {
		if n & 1 != 0 {
			r = r * a % m;
		}
		a = a * a % m;
		n >>= 1;
	}
	r
}