P3233 [HNOI2014]世界树

最新推荐文章于 2021-10-01 14:53:00 发布

weixin_30522095

最新推荐文章于 2021-10-01 14:53:00 发布

阅读量103

点赞数

原文链接：http://www.cnblogs.com/olinr/p/10230588.html

版权

\(\color{#0066ff}{ 题目描述 }\)

世界树是一棵无比巨大的树，它伸出的枝干构成了整个世界。在这里，生存着各种各样的种族和生灵，他们共同信奉着绝对公正公平的女神艾莉森，在他们的信条里，公平是使世界树能够生生不息、持续运转的根本基石。

世界树的形态可以用一个数学模型来描述：世界树中有 \(n\) 个种族，种族的编号分别从 \(1\) 到 \(n\)，分别生活在编号为 \(1\) 到 \(n\) 的聚居地上，种族的编号与其聚居地的编号相同。有的聚居地之间有双向的道路相连，道路的长度为 \(1\)。保证连接的方式会形成一棵树结构，即所有的聚居地之间可以互相到达，并且不会出现环。定义两个聚居地之间的距离为连接他们的道路的长度；例如，若聚居地 \(a\) 和 \(b\) 之间有道路，\(b\) 和\(c\) 之间有道路，因为每条道路长度为 \(1\) 而且又不可能出现环，所以 \(a\) 与\(c\) 之间的距离为 \(2\)。

出于对公平的考虑，第 \(i\) 年，世界树的国王需要授权 \(m_i\) 个种族的聚居地为临时议事处。对于某个种族\(x\)x（\(x\)x 为种族的编号），如果距离该种族最近的临时议事处为 \(y\)（\(y\) 为议事处所在聚居地的编号），则种族 \(x\) 将接受 \(y\) 议事处的管辖（如果有多个临时议事处到该聚居地的距离一样，则 \(y\) 为其中编号最小的临时议事处）。

现在国王想知道，在 \(q\) 年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。

\(\color{#0066ff}{输入格式}\)

第一行为一个正整数n，表示世界树中种族的个数。接下来n-l行，每行两个正整数x，y，表示x聚居地与y聚居地之间有一条长度为1的双向道路。接下来一行为一个正整数q，表示国王询问的年数。接下来q块，每块两行：第i块的第一行为1个正整数m[i]，表示第i年授权的临时议事处的个数。第i块的第二行为m[i]个正整数h[l]、h[2]、...、h[m[i]]，表示被授权为临时议事处的聚居地编号（保证互不相同）。

\(\color{#0066ff}{输出格式}\)

输出包含q行，第i行为m[i]个整数，该行的第j(j=1，2...，，m[i])个数表示第i年被授权的聚居地h[j]的临时议事处管理的种族个数。

\(\color{#0066ff}{输入样例}\)

\(\color{#0066ff}{输出样例}\)

\(\color{#0066ff}{数据范围与提示}\)

N<=300000, q<=300000,m[1]+m[2]+...+m[q]<=300000

\(\color{#0066ff}{ 题解 }\)

由题可知关键点是比较少的

可以用虚树来做

虚树就是原树中，只保留一些关键点以及互相通达的路径（就是所有LCA也要留下）其余点忽略构成的树

用栈来维护一天深度递增的链，每次来一个点，先找它的LCA

为了防止栈顶与栈顶-1两个点跨过LCA，先把没用的弹掉，特盘一下LCA连边，然后改变链的方向

构建完虚树后，开始收集ans

dfs1，处理出dep，siz，倍增LCA的一些东西

dfs2，求出虚树上每个点到其子树内的关键的点的最小距离及其编号（用pair），记为d[i]

dfs3，维护当前子树之外的最小距离和编号，使d[i]成为当前点到关键点的最小距离

dfs4，可以发现，对于虚树上的某一点，如果他的孩子的子树中没有关键点，那么这个点就会收集到子树内所有点的贡献（从虚树上的儿子倍增，找到原树上的儿子）

用单步容斥，先加上当前子树的siz，再减去所有有关键点的子树siz

dfs5，统计子树内有关键点中的贡献，那么两个关键点必为一浅一深，找到中间深度，然后上半部分的所有点（除了当前子树，用siz作差）都是x所属的，剩下的是子树所属的

#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
struct node{
    int to;
    node *nxt;
    node(int to = 0, node *nxt = NULL): to(to), nxt(nxt) {}
    void *operator new (size_t) {
        static node *S = NULL, *T = NULL;
        return (S == T) && (T = (S = new node[1024]) + 1024), S++;
    }
};
const int maxn = 3e5 + 100;
const int inf = 0x7f7f7f7f;
node *h[maxn], *head[maxn];
int dep[maxn], a[maxn], b[maxn], dfn[maxn], p[maxn];
int st[maxn], top;
int n, cnt;
using std::pair;
using std::make_pair;
pair<int, int> d[maxn];
int f[maxn][27], siz[maxn], ans[maxn], up[maxn];
bool vis[maxn];
void add(int from, int to, node **hh) {
    hh[from] = new node(to, hh[from]);
}
void dfs1(int x, int fa) {
    dep[x] = dep[fa] + 1;
    f[x][0] = fa;
    siz[x] = 1;
    dfn[x] = ++cnt;
    for(node *i = h[x]; i; i = i->nxt) 
        if(i->to != fa) dfs1(i->to, x), siz[x] += siz[i->to];
}

void dfs2(int x) {
    if(vis[x]) d[x] = make_pair(0, x);
    else d[x] = make_pair(inf, 0);
    for(node *i = head[x]; i; i = i->nxt)
        dfs2(i->to), d[x] = std::min(d[x], make_pair(d[i->to].first + dep[i->to] - dep[x], d[i->to].second));
}

void dfs3(int x, int dis, int pos) {
    if(d[x] > make_pair(dis, pos)) d[x] = make_pair(dis, pos);
    else dis = d[x].first, pos = d[x].second;
    for(node *i = head[x]; i; i = i->nxt)
        dfs3(i->to, dis + dep[i->to] - dep[x], pos);
}

void dfs4(int x) {
    p[x] = d[x].second;
    ans[p[x]] += siz[x];
    for(node *i = head[x]; i; i = i->nxt) {
        int o = i->to;
        for(int j = 25; j >= 0; j--) if(dep[f[o][j]] > dep[x]) o = f[o][j];
        ans[p[x]] -= siz[up[i->to] = o];
        dfs4(i->to);
    }
}

void dfs5(int x) {
    for(node *i = head[x]; i; i = i->nxt) {
        int u = up[i->to];
        if(p[x] == p[i->to]) ans[p[x]] += siz[u] - siz[i->to];
        else {
            int mid = dep[p[i->to]] + dep[x] - d[x].first;
            //如果是一条链，很容易发现是正确的
            //不是一条直链，因为x最近的不是子树最近的，所以mid一定在x到子树的链上
            mid = mid & 1? (mid + 1) >> 1 : (p[x] < p[i->to]? (mid >> 1) + 1 : (mid >> 1));
            int o = i->to;
            for(int j = 25; j >= 0; j--) if(dep[f[o][j]] >= mid) o = f[o][j];
            ans[p[x]] += siz[u] - siz[o];
            ans[p[i->to]] += siz[o] - siz[i->to];
        }
        dfs5(i->to);
    }
}

void dfs6(int x) {
    up[x] = p[x] = 0;
    for(node *i = head[x]; i; i = i->nxt)
        dfs6(i->to);
    head[x] = NULL;
}

int LCA(int x, int y) {
    if(dep[x] < dep[y]) std::swap(x, y);
    for(int i = 25; i >= 0; i--) if(dep[f[x][i]] >= dep[y]) x = f[x][i];
    if(x == y) return x;
    for(int i = 25; i >= 0; i--) if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
    return f[x][0];
}

int main() {
    n = in();
    int x, y;
    for(int i = 1; i < n; i++) x = in(), y = in(), add(x, y, h), add(y, x, h);
    dfs1(1, 0);
    for(int j = 1; j <= 25; j++)
        for(int i = 1; i <= n; i++)
            f[i][j] = f[f[i][j - 1]][j - 1];
    for(int T = in(); T --> 0;) {
        int num = in();
        for(int i = 1; i <= num; i++) b[i] = a[i] = in(), vis[a[i]] = true;
        std::sort(a + 1, a + num + 1, [](const int &x, const int &y) { return dfn[x] < dfn[y]; });
        st[top = 1] = a[1];
        for(int i = 2; i <= num; i++) {
            int now = a[i], lca = LCA(st[top], now);
            while(top > 1 && dep[st[top - 1]] >= dep[lca]) add(st[top - 1], st[top], head), top--;
            if(st[top] != lca) add(lca, st[top], head), st[top] = lca;
            st[++top] = now;
        }
        while(top > 1) add(st[top - 1], st[top], head), top--;
        int root = st[1];
        dfs2(root);
        dfs3(root, d[root].first, d[root].second);
        dfs4(root), dfs5(root);
        ans[p[root]] += siz[1] - siz[root];
        for(int i = 1; i <= num; i++) printf("%d%c", ans[b[i]], i == num? '\n' : ' ');
        dfs6(root);
        for(int i = 1; i <= num; i++) vis[a[i]] = 0, ans[a[i]] = 0;
    }
    return 0;
}

转载于:https://www.cnblogs.com/olinr/p/10230588.html