题目地址:P5305 [GXOI/GZOI2019]旧词

这里是官方题解

\[\sum_{i \leq x}^{}\ depth(lca(i,y))^k\]

\(k = 1\)

求的是 \(\sum_{i \leq x}^{}\ depth(lca(i,y))\) ,一堆点然后每个点和 \(y\) 求 \(lca\) 然后深度求和。

总体思路是把 \(lca\) 的值摊派到这个点到根的路径上(这个东西也叫树上差分?),再离线解决所有询问。

维护一个点权数组 \(sum\) ,初始为 \(0\) ,然后将 \(y\) 到根的每个点的点权设为 \(1\) ,然后对于每个点 \(i \leq x\) ,求从 \(i\) 到根的权值和为上面要求的答案,但这样就 \(O(n)\) 了。

(可以反向考虑),维护一个点权数组 \(sum\) ,初始为 \(0\) ,对于小于等于 \(x\) 的点 \(i\) ,将 \(i\) 到根的路径上所有点的点权 ++ 。然后求从 \(y\) 到根的权值和也是上面要求的答案。这种方法求可以按 \(x\) 排序,然后离线, \(x\) 相等的询问一块问。

可以树链剖分 + 线段树解决。 \(O(nlog^2n)\) 。或者 LCT 也行。

\(k > 1\)

\(k = 2\) 的话,按照上述思路想,把 \(lca^2\) 的值摊到到根的路径上的话就不是之前的 \(1,1,1,...\) ,变成了 \(1,3,5,...\) 直接看的话问题变成了线段树区间加等差数列,好像改一下线段树实现也能做(所以给了点部分分)。

但是 \(k > 2\) 的时候就比较麻烦了。

基于把 \(lca^k\) 摊到从这个点到根的路径上这个思路,实际上对于深度是 \(x\) 的点来说,这个点每次点权增加的值固定是 \(x ^ k - (x - 1) ^ k\) 。

所以实际上,线段树打标记只用记录每个点被算了多少次 \(cnt\) 即可。然后实际上的权值和是 \(sum_i = cnt_i * (dep_i^k -(dep_i - 1)^k)\) ,每次操作只有 \(cnt\) 区间加 \(1\) ,于是预处理线段树上每个区间的 \(\sum (dep_i^k -(dep_i - 1)^k)\) 后就可以直接拿线段树维护 \(sum\) 数组。

于是还是之前的树链剖分 + 线段树解决。 \(O(nlog^2n)\) 。或者 LCT 也行。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>

// by zrt
// zhangruotian@foxmail.com

using namespace std;

typedef long long LL;

const int MAXN = 50000+5;
const LL mod = 998244353;

int n,Q,k;
int H[MAXN], X[MAXN], P[MAXN], tot;
int fa[MAXN], dep[MAXN], dfn[MAXN], invdfn[MAXN], siz[MAXN], son[MAXN], top[MAXN];

inline void add(int x,int y) {
    P[++tot]=y;
    X[tot]=H[x];
    H[x]=tot;
}

struct Query {
    int x,y,id;
} query[MAXN];

int ans[MAXN];

bool cmp_by_x(Query a, Query b) {
    return a.x<b.x;
}

void dfs1(int x) {
    dep[x] = dep[fa[x]] + 1;
    siz[x] = 1;
    for(int i=H[x]; i; i=X[i]) {
        dfs1(P[i]);
        siz[x] += siz[P[i]];
        if(siz[P[i]]>siz[son[x]]) {
            son[x] = P[i];
        }
    }
}

int tim;

void dfs2(int x) {
    dfn[x] = ++tim;
    if(!top[x]) top[x]=x;
    if(son[x]) top[son[x]] = top[x], dfs2(son[x]);
    for(int i=H[x]; i; i=X[i]) {
        if(P[i] == son[x]) continue;
        dfs2(P[i]);
    }
}

LL pow(LL a,LL b,LL p) {
    LL ret = 1%p;
    while(b) {
        if(b&1) ret = ret*a%p;
        b>>=1;
        a=a*a%p;
    }
    return ret;
}

const int MAXN4 = MAXN*4;
struct SEGMENT_TREE {
    LL sum[MAXN4], cnt[MAXN4], pre[MAXN4];
    void updsum(int o) {
        sum[o] = (sum[o<<1] + sum[o<<1|1])%mod;
    }
    void bd(int o,int l,int r) {
        if(l==r) {
            pre[o] = (pow(dep[invdfn[l]],k,mod) - pow(dep[invdfn[l]]-1,k,mod) + mod)%mod;
            cnt[o] = sum[o] = 0;
        } else {
            int mid=(l+r)/2;
            bd(o<<1,l,mid);
            bd(o<<1|1,mid+1,r);
            pre[o] = (pre[o<<1]+pre[o<<1|1])%mod;
        }
    }
    void build() {
        bd(1,1,n);
    }
    void down(int o) {
        if(cnt[o]>0) {
            sum[o<<1] = (sum[o<<1]+(pre[o<<1]*cnt[o])%mod)%mod;
            cnt[o<<1] += cnt[o];
            sum[o<<1|1] = (sum[o<<1|1]+(pre[o<<1|1]*cnt[o])%mod)%mod;
            cnt[o<<1|1] += cnt[o];
            cnt[o]=0;
        }
    }
    void add(int o,int l,int r,int L,int R) {
        if(l == L && r == R) {
            sum[o] = (sum[o]+pre[o]) % mod;
            cnt[o] ++;
        } else {
            int mid=(l+r)/2;
            down(o);
            if(R<=mid) add(o<<1,l,mid,L,R);
            else if(L>mid) add(o<<1|1,mid+1,r,L,R);
            else add(o<<1,l,mid,L,mid), add(o<<1|1,mid+1,r,mid+1,R);
            updsum(o);
        }
    }
    void add(int l,int r) {
        assert(l<=r);
        add(1,1,n,l,r);
    }
    LL ask(int o,int l,int r,int L,int R) {
        if(l==L && r == R) {
            return sum[o];
        } else {
            int mid=(l+r)/2;
            down(o);
            if(R<=mid) return ask(o<<1,l,mid,L,R);
            else if(L>mid) return ask(o<<1|1,mid+1,r,L,R);
            else return (ask(o<<1,l,mid,L,mid) + ask(o<<1|1,mid+1,r,mid+1,R))%mod;
        }
    }
    LL ask(int l,int r) {
        assert(l<=r);
        return ask(1,1,n,l,r);
    }
} tree;

void prepare() {
    dfs1(1);
    dfs2(1);
    assert(tim == n);
    for(int i=1; i<=n; i++) invdfn[dfn[i]] = i;
    tree.build();
}

void add_point(int x) {
    while(x) {
        tree.add(dfn[top[x]], dfn[x]);
        x=fa[top[x]];
    }
}

LL ask(int x) {
    LL ret = 0;
    while(x) {
        ret = (ret + tree.ask(dfn[top[x]], dfn[x]))%mod;
        x=fa[top[x]];
    }
    return ret;
}

int main() {
    scanf("%d%d%d",&n,&Q,&k);
    assert(n+5 <= MAXN );
    assert(Q+5 <= MAXN );

    for(int i=2,x; i<=n; i++) {
        scanf("%d",&x);
        add(x,i);
        fa[i]=x;
    }
    for(int i=1; i<=Q; i++) {
        scanf("%d%d",&query[i].x,&query[i].y);
        query[i].id = i;
    }

    prepare();

    sort(query+1,query+Q+1,cmp_by_x);
    int p = 1;
    for(int i=1; i<=n; i++) {
        add_point(i);
        while(p <= Q && query[p].x == i) {
            ans[query[p].id] = ask(query[p].y);
            p++;
        }
    }
    assert(p==Q+1);

    for(int i=1; i<=Q; i++) {
        printf("%d\n",ans[i]);
    }

    return 0;
}

P5305 [GXOI/GZOI2019]旧词的更多相关文章

  1. luogu P5305 [GXOI/GZOI2019]旧词

    传送门 先考虑\(k=1\),一个点的深度就是到根节点的路径上的点的个数,所以\(lca(x,y)\)的深度就是\(x\)和\(y\)到根路径的交集路径上的点的个数,那么对于一个询问,我们可以对每个点 ...

  2. [LOJ3088][GXOI/GZOI2019]旧词——树链剖分+线段树

    题目链接: [GXOI/GZOI2019]旧词 对于$k=1$的情况,可以参见[LNOI2014]LCA,将询问离线然后从$1$号点开始对这个点到根的路径链修改,每次询问就是对询问点到根路径链查询即可 ...

  3. 【BZOJ5507】[GXOI/GZOI2019]旧词(树链剖分,线段树)

    [BZOJ5507][GXOI/GZOI2019]旧词(树链剖分,线段树) 题面 BZOJ 洛谷 题解 如果\(k=1\)就是链并裸题了... 其实\(k>1\)发现还是可以用类似链并的思想,这 ...

  4. BZOJ5507 GXOI/GZOI2019旧词 (树链剖分+线段树)

    https://www.cnblogs.com/Gloid/p/9412357.html差分一下是一样的问题.感觉几年没写过树剖了. #include<iostream> #include ...

  5. [GXOI/GZOI2019]旧词(树上差分+树剖)

    前置芝士:[LNOI2014]LCA 要是这题放HNOI就好了 原题:\(\sum_{l≤i≤r}dep[LCA(i,z)]\) 这题:\(\sum_{i≤r}dep[LCA(i,z)]^k\) 对于 ...

  6. [GXOI/GZOI2019]旧词

    很像LNOI 2014 LCA那道题. 同样的套路,离线以后直接扫描线. k=1的话就是原题. 考虑一般情况. 原本的做法是对x到根的这条链做一下区间+1操作,目的是为了是的在深度为i的位置得到的贡献 ...

  7. [bzoj5507] [洛谷P5305] [gzoi2019]旧词

    Descriptioin 浮生有梦三千场 穷尽千里诗酒荒 徒把理想倾倒 不如早还乡 温一壶风尘的酒 独饮往事迢迢 举杯轻思量 泪如潮青丝留他方 --乌糟兽/愚青<旧词> 你已经解决了五个问 ...

  8. P5305-[GXOI/GZOI2019]旧词【树链剖分,线段树】

    正题 题目链接:https://www.luogu.com.cn/problem/P5305 题目大意 给一棵有根树和\(k\),\(Q\)次询问给出\(x,y\)求 \[\sum_{i=1}^{x} ...

  9. BZOJ 5507: [gzoi2019]旧词 LCT

    和之前那个 [LNOI]LCA 几乎是同一道题,就是用动态树来维护查分就行. code: #include <bits/stdc++.h> using namespace std; #de ...

随机推荐

  1. 分享收集的WebGL 3D学习资源

    大家好,我在本文中分享了我收集的WebGL 3D相关的博客.书籍.教程.demo等内容,希望对大家学习WebGL和3D有所帮助,谢谢- 相关博客 Wonder技术 Wonder是我们的产品,包含Web ...

  2. openstack第六章:dashboard

    第六篇horizon— Web管理界面     一.horizon 介绍:   理解 horizon   Horizon 为 Openstack 提供一个 WEB 前端的管理界面 (UI 服务 )通过 ...

  3. opencv : imread()的应用

    概述: imread()是opencv中用于读取图片的一个工具.怎么读取图片看似一个很简单的工作,但实际上也有一些细节需要我们注意,以避免在后续的操作中出现bug. 函数原型: 函数原型: Mat i ...

  4. 【刷题】Git知识点

    参考:学习总结之Git学习-总 1-origin是什么? 答:origin 是默认的远程版本库名称,可以在 .git/config 之中进行修改.在默认情况下,origin指向的就是你本地的代码库托管 ...

  5. 自己常用易忘的CSS样式

    鼠标小手:   cursor:pointer 点击边框消失:outline:none; ul li下划线以及点消失: list-style-type:none; span 超出内容为...:overf ...

  6. 时间插件datepicker(jQuery-UI,bootstrap)和jquery-steps的冲突解决。。。

    日期插件初始化:  $('.prelease_time').flatpickr(); let contentSteps = $("#content_form").steps({ h ...

  7. JQ倒计时,正计时

    <p class="lastP">距离二维码过期还剩<strong></strong>秒,过期后自动刷新页面.</p><scr ...

  8. mysql-笔记 隔离级别、事务

    1 隔离级别:低级别的隔离通常可以执行更高的并发,系统 开销也更低 2 Read uncommitted:事务可以读取未提交的数据,脏读,应少用 3 read committed:不可重复读,事务只能 ...

  9. delphi中响应鼠标进入或离开控件的方法

    Delphi没有MouseEnter与MouseLeave的事件,网上说可以响应CM_MOUSEENTER和CM_MOUSELEAVE消息来实现.这两个消息是VCL自己定义的消息,看了Delphi的C ...

  10. BZOJ2406矩阵——有上下界的可行流+二分答案

    题目描述 输入 第一行两个数n.m,表示矩阵的大小. 接下来n行,每行m列,描述矩阵A. 最后一行两个数L,R. 输出 第一行,输出最小的答案: 样例输入 2 2 0 1 2 1 0 1 样例输出 1 ...