磨魔树

题目来源：http://oj.flyioi.cn/contest/9/problem/39

题目描述

陶陶的院子里有一棵由n个点，n-1条树枝构成的魔树，陶陶最大的业余爱好就是磨一磨这棵魔树，他每一次磨树都会选择三个点，不妨设这三点为a,b,c，从a磨到b，从b磨到c，从c磨到a。(a,b,c的任意一种排列被视为同一方案）然而这棵树被磨了许多次，某些树枝再磨一次就被磨烂了。陶陶认为若a->b,b->c,c->a上都有树枝被他磨烂，则这次磨树是失败的。现在他想问你，他下一次磨树，失败的概率是多少？

输入格式

 第一行输入n，表示点的数目
 第二到n行，每行输入三个数u，v，p。表示u->v有一条边，若p=1，则这条边是要烂的边，否则是不会烂的边。

输出格式

输出的概率为一个在对1e9+7取模意义下的分数，
即一个整数。

样例输入

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

样例输出

800000006

样例解释

样例一有4种方案磨烂，一共10种方案，概率为2/5，取模意义下为800000006

思路：组成几个联通块，把所有不磨烂的方案算出来就可以了，最后求一个逆元。

/*************************************************************************
    > Author: wzw-cnyali
    > Created Time: 2017/3/12 14:09:15
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>

using namespace std;

typedef unsigned long long LL;

#define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)
#define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define mem(a, b) memset((a), b, sizeof(a))

template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

int read()
{
	int sum = 0, fg = 1; char c = getchar();
	while(c < '0' || c > '9') { if (c == '-') fg = -1; c = getchar(); }
	while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }
	return sum * fg;
}

const int Size = 200010;
const int inf = 0x3f3f3f3f;
const LL mod = 1e9 + 7;

LL C[Size][5];

void get_C(int n)
{
	REP(i, 0, n) { C[i][0] = 1; C[i][i <= 3 ? i : 3] = 1; }
	REP(i, 1, n) REP(j, 1, i <= 3 ? i : 3) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}

int be[Size], to[Size], nxt[Size], w[Size], e;

void add(int x, int y, int z) { to[e] = y; nxt[e] = be[x]; be[x] = e; w[e] = z; e++; }

int size[Size], id[Size], cnt;
bool vis[Size];

void dfs(int x)
{
	vis[x] = 1;
	for(int i = be[x]; i != -1; i = nxt[i])
	{
		int v = to[i];
		if(vis[v]) continue;
		if(!w[i]) { id[v] = id[x]; ++size[id[v]]; }
		else { id[v] = ++cnt; ++size[cnt]; }
		dfs(v);
	}
}

LL extend_gcd(LL a, LL b, LL &x, LL &y)
{
	if(!b) { x = 1; y = 0; return a; }
	LL gcd = extend_gcd(b, a % b, y, x);
	y -= a / b * x;
	return gcd;
}

LL inv(LL p)
{
	LL x, y, gcd = extend_gcd(p, mod, x, y);
	return gcd == 1 ? ((x + mod) % mod) : -1;
}

void init(int n)
{
	get_C(n);
	mem(be, -1);
	e = 0;
}

int main()
{
	int n = read();
	init(n);
	REP(i, 1, n - 1)
	{
		int x = read(), y = read(), z = read();
		add(x, y, z); add(y, x, z);
	}
	
	size[1] = id[1] = cnt = 1;
	dfs(1);
	
	LL sum = C[n][3], ans1 = 0;
	REP(i, 1, cnt)
	{
		if(size[i] == 1) continue;
		ans1 = ((ans1 + C[size[i]][3]) % mod + (C[size[i]][2] * (n - size[i])) % mod) % mod;
	}
	LL ans = ((sum - ans1 + mod) % mod * inv(sum) + mod) % mod;
	printf("%lld\n", ans);
    return 0;
}