大厨砍树

题意：给你一棵树，第二天起每天随机砍一条边。问每一天森林的期望权值。权值为每个连通块的点数平方和。

解：先把平方拆了。发现就是点对数量 * 2，但是两个点相同的时候不 * 2，就是有序点对的数量。

然后可以求树上路径，点分治 + fft。

然后考虑我们要如何计算答案。第i天有C(n - 1, i - 1)种方案。长度为Q的路径仍然存在的方案数为C(n - 1 - Q, i - 1)

然后把这个组合数拆开，只和n，i有关的都提出来，剩下的是个卷积式子。注意卷积里面一定有一个东西的下标与两项都有关。

然后再fft一次就好了。

卡常新技巧：预处理单位根。

/**
 * There is no end though there is a start in space. ---Infinity.
 * It has own power, it ruins, and it goes though there is a start also in the star. ---Finite.
 * Only the person who was wisdom can read the most foolish one from the history.
 * The fish that lives in the sea doesn't know the world in the land.
 * It also ruins and goes if they have wisdom.
 * It is funnier that man exceeds the speed of light than fish start living in the land.
 * It can be said that this is an final ultimatum from the god to the people who can fight.
 *
 * Steins;Gate
 */

/**
 * by huyufeifei
 */

#include <bits/stdc++.h>

#define forson(x, i) for(register int i(*(e + x)); i; i = edge[i].nex)

const int N = 500010, MO = 998244353, INF = 0x3f3f3f3f;

inline char gc() {
    static char buf[N], *p1(buf), *p2(buf);
    if(p1 == p2) {
        p2 = (p1 = buf) + fread(buf, 1, N, stdin);
    }
    return p1 == p2 ? EOF : *p1++;
}

inline void read(int &x) {
    x = 0;
    register char c = gc();
    while(c < '0' || c > '9') c = gc();
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = gc();
    }
    return;
}

struct Edge {
    int nex, v;
    bool del;
}edge[N << 1]; int tp = 0;

int e[N], n, F[N], Time, vis[N], r[N << 2], bin[N], Ans[N], G[N];
int fac[N], inv[N], invn[N], A[N << 2], B[N << 2], d[N], siz[N];
int _n, root, small;
bool del[N];
int W[20][N << 2];

inline void prework(int n) {
    static int R = 0;
    if(R == n) return;
    R = n;
    int lm(1);
    while((1 << lm) < n) lm++;
    for(register int i(0); i < n; i++) {
        *(r + i) = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    }
    return;
}

inline int C(int n, int m) {
    return 1ll * (*(fac + n)) * invn[m] % MO * invn[n - m] % MO;
}

inline int qpow(int a, int b) {
    int ans(1);
    while(b) {
        if(b & 1) ans = 1ll * ans * a % MO;
        a = 1ll * a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline void Add(int &a, const int &b) {
    a += b % MO;
    while(a >= MO) a -= MO;
    while(a < 0) a += MO;
    return;
}

#define add(x, y) tp++; edge[tp].v = y; edge[tp].nex = e[x]; e[x] = tp

/*inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}*/

inline void preworkW() {
    for(int len(1), lm(1); lm < 20; len <<= 1, lm++) {
        int Wn = qpow(3, (MO - 1) / (len << 1));
        W[lm][0] = 1;
        //printf("W %d 0 = 1  Wn = %d 
", lm, Wn);
        for(int j = 1; j <= len * 2; j++) {
            W[lm][j] = 1ll * W[lm][j - 1] * Wn % MO;
        }
        //printf("W[lm][len * 2] = %d 
", W[lm][len * 2]);
    }
    return;
}

inline void NTT(int *a, int n, int f) {
    prework(n);
    for(register int i(0); i < n; i++) {
        if(i < *(r + i)) std::swap(a[i], a[r[i]]);
    }
    for(register int len(1), lm(1); len < n; len <<= 1, lm++) {
        int Wn = qpow(3, (MO - 1) / (len << 1));
        if(f == -1) Wn = qpow(Wn, MO - 2);
        for(register int i(0); i < n; i += (len << 1)) {
            int w2(1);
            for(register int j(0), p(f == 1 ? 0 : len * 2); j < len; j++, p += f) {
                int w = W[lm][p];
                //if(w != w2) printf("ERR : len = %d lm = %d j = %d w = %d w2 = %d 
", len, lm, j, w, w2);
                int t = 1ll * a[i + len + j] * w % MO;
                a[i + len + j] = (a[i + j] - t) % MO;
                a[i + j] = (a[i + j] + t) % MO;
                w2 = 1ll * w2 * Wn % MO;
            }
        }
    }
    if(f == -1) {
        int inv = qpow(n, MO - 2);
        for(register int i(0); i < n; i++) {
            a[i] = 1ll * (*(a + i)) * inv % MO;
        }
    }
    return;
}

inline void cal(int n, int f) {
    int len = 1;
    n++;
    while(len < n * 2) len <<= 1;
    memcpy(A, bin, n * sizeof(int));
    memset(A + n, 0, (len - n) * sizeof(int));
    NTT(A, len, 1);
    for(register int i(0); i < len; i++) {
        *(A + i) = 1ll * (*(A + i)) * (*(A + i)) % MO;
    }
    NTT(A, len, -1);
    for(register int i(0); i < len; i++) {
        (*(Ans + i) += f * (*(A + i))) %= MO;
    }
    return;
}

void getroot(int x, int f, int flag) {
    if(flag) {
        (*(bin + (*(d + x))))++;
    }
    *(siz + x) = 1;
    int large(0);
    forson(x, i) {
        int y = edge[i].v;
        if(y == f || (*(del + y))) continue;
        getroot(y, x, flag);
        *(siz + x) += *(siz + y);
        large = std::max(large, *(siz + y));
    }
    large = std::max(large, _n - (*(siz + x)));
    if(large < small) {
        small = large;
        root = x;
    }
    return;
}

void DFS_1(int x, int f) {
    *(d + x) = *(d + f) + 1;
    (*(bin + (*(d + x))))++;
    *(siz + x) = 1;
    forson(x, i) {
        int y = edge[i].v;
        if(y == f || (*(del + y))) {
            continue;
        }
        DFS_1(y, x);
        *(siz + x) += *(siz + y);
    }
    return;
}

//int Cnt;

void poi_div(int x, int f) {

    // printf("x = %d _n = %d last_n = %d f = %d 
", x, _n, last_n, f);
    //printf("x = %d  Cnt = %d 
", x, ++Cnt);

    if(f) memset(bin, 0, (_n + 1) * sizeof(int));
    small = INF;
    getroot(x, 0, f);
    if(f) cal(_n, -1);
    x = root;

    //printf("root = %d 
", root);

    memset(bin, 0, (_n + 1) * sizeof(int));
    //printf("gast 0  
");
    DFS_1(x, 0);
    //printf("gast 1  
");
    cal(_n, 1);

    *(del + x) = 1;
    memset(bin, 0, (_n + 1) * sizeof(int));
    forson(x, i) {
        int y = edge[i].v;
        if(del[y]) continue;
        _n = *(siz + y);
        poi_div(y, 1);
    }
    return;
}

int main() {

    *d = -1;
    read(n);

    preworkW();

    *inv = *invn = *fac = 1;
    *(inv + 1) = *(invn + 1) = *(fac + 1) = 1;
    for(register int i(2); i <= n; i++) {
        *(fac + i) = 1ll * (*(fac + i - 1)) * i % MO;
        *(inv + i) = 1ll * (*(inv + MO % i)) * (MO - MO / i) % MO;
        *(invn + i) = 1ll * (*(invn + i - 1)) * (*(inv + i)) % MO;
    }

    for(register int i(1), x, y; i < n; i++) {
        read(x); read(y);
        add(x, y); add(y, x);
    }

    _n = n;
    poi_div(1, 0);

    for(register int i(0); i < n; i++) {
        //printf("%d ", (Ans[i] + MO) % MO);
        *(F + i) = 1ll * (*(Ans + i)) * (*(fac + n - i - 1)) % MO;
        *(G + i) = *(invn + i);
    }

    int len(1);
    while(len < (n << 1)) len <<= 1;
    memcpy(A, F, n * sizeof(int));
    memcpy(B, G, n * sizeof(int));
    memset(A + n, 0, (len - n) * sizeof(int));
    memset(B + n, 0, (len - n) * sizeof(int));
    NTT(A, len, 1); NTT(B, len, 1);
    for(register int i(0); i < len; i++) {
        *(Ans + i) = 1ll * (*(A + i)) * (*(B + i)) % MO;
    }
    NTT(Ans, len, -1);

    //printf("OVER 
");

    for(register int i(1); i <= n; i++) {
        int ans = 1ll * (*(Ans + n - i)) * (*(invn + n - 1)) % MO * (*(fac + n - i)) % MO;
        printf("%d
", (ans + MO) % MO);
    }

    return 0;
}