Codeforces 833D Red-black Cobweb【树分治】

D. Red-black Cobweb

time limit per test：6 seconds

memory limit per test：256 megabytes

input：standard input

output：standard output

Slastyona likes to watch life of nearby grove's dwellers. This time she watches a strange red-black spider sitting at the center of a huge cobweb.

The cobweb is a set of n nodes connected by threads, each of the treads is either red of black. Using these threads, the spider can move between nodes. No thread connects a node to itself, and between any two nodes there is a unique sequence of threads connecting them.

Slastyona decided to study some special qualities of the cobweb. She noticed that each of the threads has a value of clamminess x.

However, Slastyona is mostly interested in jelliness of the cobweb. Consider those of the shortest paths between each pair of nodes on which the numbers of red and black threads differ at most twice. For each such path compute the product of the clamminess of threads on the path.The jelliness of the cobweb is the product of all obtained values among all paths. Those paths that differ by direction only are counted only once.

Of course, this number can be huge, so Slastyona asks you to compute the jelliness of the given cobweb and print the answer modulo 10⁹ + 7.

Input

The first line contains the number of nodes n (2 ≤ n ≤ 10⁵).

The next n - 1 lines contain four integers each, denoting the i-th thread of the cobweb: the nodes it connects u_i, v_i (1 ≤ u_i ≤ n, 1 ≤ v_i ≤ n), the clamminess of the thread x_i (1 ≤ x ≤ 10⁹ + 6), and the color of the thread c_i (). The red color is denoted by 0, and the black color is denoted by 1.

Output

Print single integer the jelliness of the cobweb modulo 10⁹ + 7. If there are no paths such that the numbers of red and black threads differ at most twice, print 1.

Examples

Input

5
1 2 9 0
2 3 5 1
2 4 5 0
2 5 5 1

Output

1265625

Input

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

Output

452841614

Note

In the first example there are 4 pairs of nodes such that the numbers of threads of both colors on them differ at most twice. There pairs are (1, 3) with product of clamminess equal to 45, (1, 5) with product of clamminess equal to 45, (3, 4) with product of clamminess equal to 25 and (4, 5) with product of clamminess equal to 25. The jelliness of the cobweb is equal to 1265625.

题目链接：http://codeforces.com/contest/833/problem/D

官方题解：

下面给出AC代码：

 #include <cstdio>
 #include <cstring>
 #include <utility>
 #include <vector>

 const int N = ;
 const int MOD = (int)1e9 + ;

 struct Edge { int v, x, c; };
 struct Sum { int c, p; };

 Sum& operator += (Sum& a, const Sum& b)
 {
     a.c += b.c;
     a.p = (long long)a.p * b.p % MOD;
 }

 int n, m, result, size[N], imbalance[N], w[];
 bool resolved[N];
 Sum sum[N << ];
 std::vector<int> vertices;
 std::vector<std::pair<int, int>> todos;
 std::vector<Edge> tree[N];

 int pow(int a, int n)
 {
     int result = ;
     while (n) {
         if (n & ) {
             result = (long long)result * a % MOD;
         }
         a = (long long)a * a % MOD;
         n >>= ;
     }
     return result;
 }

 int prepare(int p, int u)
 {
     int size = ;
     for (auto&& iterator : tree[u]) {
         auto v = iterator.v;
         if (v != p) {
             int s = prepare(u, v);
             result = (long long)result * pow(iterator.x, (long long)s * (n - s) % (MOD - )) % MOD;
             size += s;
         }
     }
     return size;
 }

 int prepare2(int p, int u)
 {
     vertices.push_back(u);
     size[u] = , imbalance[u] = ;
     for (auto&& iterator : tree[u]) {
         auto&& v = iterator.v;
         if (v != p && !resolved[v]) {
             prepare2(u, v);
             size[u] += size[v];
             imbalance[u] = std::max(imbalance[u], size[v]);
         }
     }
 }

 void add(int k, const Sum& v)
 {
     for (; k < m << ; k += ~k & k + ) {
         sum[k] += v;
     }
 }

 void dfs(int p, int u, int offset, int product)
 {
     todos.emplace_back(offset, product);
     Sum s {, };
     for (int k = offset - ; k >= ; k -= ~k & k + ) {
         s += sum[k];
     }
     result = (long long)result * pow((long long)pow(product, s.c) * s.p % MOD, MOD - ) % MOD;
     for (auto&& iterator : tree[u]) {
         auto&& v = iterator.v;
         if (v != p && !resolved[v]) {
             dfs(u, v, offset + w[iterator.c], (long long)product * iterator.x % MOD);
         }
     }
 }

 void divide(int root)
 {
     vertices.clear();
     prepare2(-, root);
     m = size[root];
     for (auto&& u : vertices) {
         imbalance[u] = std::max(imbalance[u], m - size[u]);
     }
     for (auto&& u : vertices) {
         if (imbalance[u] < imbalance[root]) {
             root = u;
         }
     }
     for (int t = ; t < ; ++ t) {
         w[t] = , w[t ^ ] = -;
         for (int i = ; i < m << ; ++ i) {
             sum[i] = {, };
         }
         add(m << , {, });
         for (auto&& iterator : tree[root]) {
             auto&& v = iterator.v;
             if (!resolved[v]) {
                 dfs(root, v, (m << ) + w[iterator.c], iterator.x);
                 for (auto&& todo : todos) {
                     add((m << ) - todo.first, {, todo.second});
                 }
                 todos.clear();
             }
         }
     }
     resolved[root] = true;
     for (auto&& iterator : tree[root]) {
         auto&& v = iterator.v;
         if (!resolved[v]) {
             divide(v);
         }
     }
 }

 int main()
 {
 #ifdef LOCAL_JUDGE
     freopen("D.in", "r", stdin);
 #endif
     while (scanf("%d", &n) == ) {
         for (int i = ; i < n; ++ i) {
             tree[i].clear();
         }
         for (int i = , a, b, x, c; i < n - ; ++ i) {
             scanf("%d%d%d%d", &a, &b, &x, &c);
             a --;
             b --;
             tree[a].push_back({b, x, c});
             tree[b].push_back({a, x, c});
         }
         result = ;
         prepare(-, );
         memset(resolved, , sizeof(*resolved) * n);
         divide();
         printf("%d\n", result);
     }
 }