Solution -「HDU 6643」Ridiculous Netizens

$\mathcal{Description}$

  Link.

  给定一棵含有 $n$ 个结点的树，点 $u$ 有点权 $w_u$，求树上非空连通块的数量，使得连通块内点权积 $\le m$。

  $n\le2\times10^3$，$m\le10^6$，$w_u\in[1,m]$，数据组数 $T\le10$。

$\mathcal{Solution}$

  很明显是点分，每次考虑跨当前分治重心 $r$ 的所有连通块对答案的贡献。问题变为：求树上以 $r$ 为根的满足条件的连通块数量。

  一个简单的想法是以子树为子问题树上 DP，但是点权积的状态空间与子树大小完全无关，子树与子树的合并反而更加浪费时间，这提示我们，应该设计一种仅有单点更新的 DP 状态——以 DFN 为子问题 DP。

  另一方面，由于运算全部是乘法，可以考虑整除分块的储存方式压缩状态树。令 $f(u,i)$ 表示当 DFS 进行到某一时刻时，以 $u$ 子树内已经被搜过的点为最大 DFN 点的连通块中，点权积在整除分块后被映射到 $i$ 的方案数。进入 $u$ 子树时用 $u$ 的父亲更新 $f(u)$，退出 $u$ 子树时将 $f(u)$ 上传给 $u$ 的父亲。设树的大小为 $s$，DP 的复杂度为 $\mathcal O(s\sqrt m)$。

  最终，算法复杂度为 $\mathcal O(Tn\sqrt m\log n)$。

$\mathcal{Code}$

/*+Rainybunny+*/

#include <bits/stdc++.h>

#define rep(i, l, r) for (int i = l, rep##i = r; i <= rep##i; ++i)
#define per(i, r, l) for (int i = r, per##i = l; i >= per##i; --i)

typedef long long LL;

const int MAXN = 2e3, MOD = 1e9 + 7, THRES = 1e3;
int n, m, thres, ecnt, val[MAXN + 5], head[MAXN + 5];
int siz[MAXN + 5], wgt[MAXN + 5], ans;
int f[MAXN + 5][THRES * 2 + 5], g[MAXN + 5][THRES * 2 + 5];
struct Edge { int to, nxt; } graph[MAXN * 2 + 5];
bool vis[MAXN + 5];

inline void chkmax(int& u, const int v) { u < v && (u = v); }
inline int imin(const int u, const int v) { return u < v ? u : v; }
inline void addeq(int& u, const int v) { (u += v) >= MOD && (u -= MOD); }

inline void link(const int u, const int v) {
    graph[++ecnt] = { v, head[u] }, head[u] = ecnt;
    graph[++ecnt] = { u, head[v] }, head[v] = ecnt;
}

inline void findG(const int u, const int fa, const int all, int& rt) {
    siz[u] = 1, wgt[u] = 0;
    for (int i = head[u], v; i; i = graph[i].nxt) {
        if (!vis[v = graph[i].to] && v != fa) {
            findG(v, u, all, rt), siz[u] += siz[v];
            chkmax(wgt[u], siz[v]);
        }
    }
    chkmax(wgt[u], all - siz[u]);
    if (!rt || wgt[rt] > wgt[u]) rt = u;
}

inline void getDP(const int u, const int fa) {
    int *fcur = f[u], *ffa = f[fa];
    rep (i, 0, thres << 1) fcur[i] = 0;
    if (!fa) fcur[val[u] <= thres ? val[u] : thres + m / val[u]] = 1;
    else {
        rep (i, 0, imin(thres, m / val[u])) {
            int t = i * val[u];
            addeq(fcur[t <= thres ? t : thres + m / t], ffa[i]);
        }
        rep (i, val[u], thres) {
            addeq(fcur[thres + i / val[u]], ffa[thres + i]);
        }
    }
    for (int i = head[u], v; i; i = graph[i].nxt) {
        if (!vis[v = graph[i].to] && v != fa) {
            getDP(v, u);
        }
    }
    if (fa) rep (i, 0, thres << 1) addeq(ffa[i], fcur[i]);
}

inline void solve(const int u) {
    // printf("!%d\n", u);
    vis[u] = true, getDP(u, 0);
    rep (i, 0, thres << 1) addeq(ans, f[u][i]);
    for (int i = head[u], v, rt; i; i = graph[i].nxt) {
        if (!vis[v = graph[i].to]) {
            findG(v, 0, siz[v], rt = 0), solve(rt);
        }
    }
}

inline void allClear() {
    ans = ecnt = 0;
    rep (i, 1, n) head[i] = vis[i] = 0;
}

int main() {
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &n, &m), thres = int(sqrt(1. * m));
        allClear();
        rep (i, 1, n) scanf("%d", &val[i]);
        rep (i, 2, n) { int u, v; scanf("%d %d", &u, &v), link(u, v); }
        int rt = 0; findG(1, 0, n, rt);
        solve(rt), printf("%d\n", ans);
    }
    return 0;
}