校内题目腐草为萤

2.腐草为萤 (dzy.cpp/c)
【题目背景】
纤弱的 淤泥中妖冶
颓废在 季夏第三月
最幼嫩的新叶 连凋零都不屑
何必生离死别
——银临《腐草为萤》
【问题描述】 扶苏给了你一棵树，这棵树上长满了幼嫩的新叶，我们约定这棵树的根是 1，每个节 点都代表树上的一个叶子。 如果你不知道什么叫树，你可以认为树是一个边数比节点个数少 1 的无向连通图。 我们如果约定节点 u 是树 T 的根，则可以定义一个节点 v 到根的路径为该无向图上 u,v 两个节点之间的简单路径上的节点集合(包括路径的两个端点)。可以证明，这样的简单路 径只有一条。 我们定义节点 x 是节点 y 的祖先(xy)，当且仅当 x 在 y 到根的路径上。 现在扶苏想在这棵树上选定一个集合，将其称之为幼嫩集合，来比较集合中的节点 哪个最幼嫩。注意到一旦集合中存在两个节点 u,v，使得 u 是 v 的祖先，那么一定 v 要比 u 更幼嫩，因为 v 是在 u 的枝丫上生长出来的，那么这样的集合就是没有意义的。也就是 说，扶苏所选择的集合一定满足要求“对于任意集合中的元素对 (u,v)，u 不是 v 的祖 先”。 扶苏其实对这些节点哪个最幼嫩并不感兴趣，也对他能选出多少集合不感兴趣，因 为这些都是为了问你下面的问题而创造出的题目背景。 扶苏给每个节点都定义了一个权值，具体的，我们会给出一个参数 T，规定 i 号节点 的权值为 T i 。 我们定义一个幼嫩集合幼嫩指数为集合内节点的权值和。现在扶苏想请问你，对于 他所有可能选出的集合，这些集合的幼嫩指数之和是多少。 为了避免答案过大，请你输出答案对 7109取模的结果。
【输入格式】 输入文件名为 dzy.in。 输入文件中有且仅有一组数据，第一行为两个正整数 n 和 T,节点个数和权值参 数。 下面 n-1 行，每行有两个正整数 u,v，代表树上有一条边连接节点 u 和节点 v。
【输出格式】 输出文件名为 dzy.out。 输出一行一个正整数，代表答案对 7109  取模的结果。

5 0

1 2

2 3

2 4

1 5

输出：16

题解：

---

设fufu 是以uu 为根的子树，先考虑 T = 0T = 0 的情况

当点uu 只有两个儿子 v1 , v2v1 , v2 的时候，显然 fu = fv1 + fv2 + fv1 × fv2 + 1fu = fv1 + fv2 + fv1 × fv2 + 1

考虑uu 有多个儿子的时候也类似，设 gi为考虑点 uu 的前jj 个子树的集合数，于是

gj = gj−1 × fv + gj + fvgj = gj−1 × fv + gj + fv

考虑 T ≠ 0T ≠ 0 的情况

设 fu 为以 u 为根的ans，gu 为以u 为根的集合个数

则

fu = fv × gu + fu × gv + fu +fvfu = fv × gu + fu × gv + fu +fv

gu = gu + gv + gu × gv

#include <cstdio>
#ifdef ONLINE_JUDGE
#define freopen(a, b, c)
#endif
#define rg register
#define ci const int
#define cl const long long

typedef long long int ll;

namespace IPT {
    const int L = 1000000;
    char buf[L], *front=buf, *end=buf;
    char GetChar() {
        if (front == end) {
            end = buf + fread(front = buf, 1, L, stdin);
            if (front == end) return -1;
        }
        return *(front++);
    }
}

template <typename T>
inline void qr(T &x) {
    rg char ch = IPT::GetChar(), lst = ' ';
    while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();
    while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();
    if (lst == '-') x = -x;
}

template <typename T>
inline void ReadDb(T &x) {
    rg char ch = IPT::GetChar(), lst = ' ';
    while ((ch > '9') || (ch < '0')) lst = ch, ch = IPT::GetChar();
    while ((ch >= '0') && (ch <= '9')) x = x * 10 + (ch ^ 48), ch = IPT::GetChar();
    if (ch == '.') {
        ch = IPT::GetChar();
        double base = 1;
        while ((ch >= '0') && (ch <= '9')) x += (ch ^ 48) * ((base *= 0.1)), ch = IPT::GetChar();
    }
    if (lst == '-') x = -x;
}

namespace OPT {
    char buf[120];
}

template <typename T>
inline void qw(T x, const char aft, const bool pt) {
    if (x < 0) {x = -x, putchar('-');}
    rg int top=0;
    do {OPT::buf[++top] = x % 10 + '0';} while (x /= 10);
    while (top) putchar(OPT::buf[top--]);
    if (pt) putchar(aft);
}

const int maxn = 1000010;
const int maxm = 2000010;
const int MOD = 100000007;

struct Edge {
    int to, nxt;
};
Edge edge[maxm]; int hd[maxn], ecnt = 1;
inline void cont(ci from, ci to) {
    Edge &e = edge[++ecnt];
    e.to = to; e.nxt = hd[from]; hd[from] = ecnt;
}

int n, t;
int MU[maxn], frog[maxn], gorf[maxn];

void reading();
void dfs(ci, ci);

int main() {
    freopen("1.in", "r", stdin);
    qr(n); qr(t);
    if (t) {
        for (rg int i = 1; i <= n; ++i) MU[i] = i;
    } else {
        for (rg int i = 1; i <= n; ++i) MU[i] = 1;
    }
    reading();
    dfs(1, 0); qw(frog[1], '
', true);
    return 0;
}

void reading() {
    int a, b;
    for (rg int i = 1; i < n; ++i) {
        a = b = 0; qr(a); qr(b);
        cont(a, b); cont(b, a);
    }
}

void dfs(ci u, ci pree) {
    for (int i = hd[u]; i; i = edge[i].nxt) if (i != pree) {
        int &to = edge[i].to;
        dfs(to, i ^ 1);
        frog[u] = (1ll * frog[to] * gorf[u] % MOD + 1ll * frog[u] * gorf[to] % MOD + frog[to] + frog[u]) % MOD;
        gorf[u] = (1ll * gorf[u] * gorf[to] % MOD + gorf[to] + gorf[u]) % MOD;
    }
    frog[u] = (frog[u] + MU[u]) % MOD;
    gorf[u] = (gorf[u] + 1) % MOD;
}

完结；