[luogu3676]小清新数据结构题

最新推荐文章于 2021-07-08 10:57:24 发布
最新推荐文章于 2021-07-08 10:57:24 发布
阅读量201 收藏
点赞数 1
分类专栏： OI 点分治 动态点分治（点分树）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouyuheng2003/article/details/88941435
版权

前言

此题貌似有不少做法

题目相关

链接

题目大意

给出一棵无根树，支持两个操作
1.修改一个点的权值
2.指定一个点，计算以其为根时每个子树权值平方和

数据范围

n , q ≤ 200000 n,q\le200000 n,q≤200000

题解

对于这题，我们发现直接维护好像不太方便
考虑转化一下问题
设 S = ∑ i = 1 n s i S=\sum_{i=1}^ns_i S=∑i=1n​si​
我们考虑一个值 ∑ i = 1 n ∑ j = 1 n s i s j d i s ( i , j ) \sum_{i=1}^n\sum_{j=1}^n s_is_jdis(i,j) ∑i=1n​∑j=1n​si​sj​dis(i,j)，我们设其为 T T T，我们发现只要不修改点权，那么 T T T就是不变的
考虑将 T T T换个形式，我们设以某个点为根， i i i号点的子树权值和是 v i v_i vi​
发现 1 2 T = ∑ i = 1 n v i ( S − v i ) \frac12T=\sum_{i=1}^nv_i(S-v_i) 21​T=∑i=1n​vi​(S−vi​)（我们发现等式右边相当于是枚举一个点，这个点的子树内的点到子树外的点贡献一个乘积，这样的话一个点对会贡献路径长度次答案）
即对于任何一个点为根，等式都成立
我们发现 T T T的值可以直接用动态点分治维护（查询所有点到一个点的距离乘权值的和，具体做法可以看幻想乡战略游戏博客）即可，复杂度大概是 O ( n l o g n ) \mathcal O(nlogn) O(nlogn)的
我们把 T T T的式子展开，我们发现
1 2 T = ∑ i = 1 n v i S − v i 2 = S ∑ i = 1 n v i − ∑ i = 1 n v i 2 \begin{aligned} \frac12T&=\sum_{i=1}^nv_iS-v_i^2 &=S\sum_{i=1}^nv_i-\sum_{i=1}^nv_i^2 \end{aligned} 21​T​=i=1∑n​vi​S−vi2​​=Si=1∑n​vi​−i=1∑n​vi2​​
即 ∑ i = 1 n v i 2 = S ∑ i = 1 n v i − 1 2 T \sum_{i=1}^nv_i^2=S\sum_{i=1}^nv_i-\frac12T i=1∑n​vi2​=Si=1∑n​vi​−21​T
容易发现 S S S很好维护，现在只要再维护 ∑ i = 1 n v i \sum_{i=1}^nv_i ∑i=1n​vi​即可
我们发现这玩意儿也很好弄
∑ i = 1 n v i = ∑ i = 1 n s i d i s ( r o o t , i ) + ∑ i = 1 n s i \sum_{i=1}^nv_i=\sum_{i=1}^ns_idis(root,i)+\sum_{i=1}^ns_i i=1∑n​vi​=i=1∑n​si​dis(root,i)+i=1∑n​si​
这玩意儿动态点分治里已经维护好了
方便起见，我这里贴一个最终的式子
∑ i = 1 n v i 2 = S ( ∑ i = 1 n s i d i s ( r o o t , i ) + ∑ i = 1 n s i ) − 1 2 ( ∑ i = 1 n ∑ j = 1 n s i s j d i s ( i , j ) ) = S ∑ i = 1 n s i d i s ( r o o t , i ) + S 2 − 1 2 ∑ i = 1 n ∑ j = 1 n s i s j d i s ( i , j ) = S ∑ i = 1 n s i d i s ( r o o t , i ) + S 2 − ∑ i = 1 n ∑ j = i + 1 n s i s j d i s ( i , j ) \begin{aligned} \sum_{i=1}^nv_i^2&=S(\sum_{i=1}^ns_idis(root,i)+\sum_{i=1}^ns_i)-\frac12(\sum_{i=1}^n\sum_{j=1}^n s_is_jdis(i,j))\\ &=S\sum_{i=1}^ns_idis(root,i)+S^2-\frac12\sum_{i=1}^n\sum_{j=1}^n s_is_jdis(i,j)\\ &=S\sum_{i=1}^ns_idis(root,i)+S^2-\sum_{i=1}^n\sum_{j=i+1}^n s_is_jdis(i,j) \end{aligned} i=1∑n​vi2​​=S(i=1∑n​si​dis(root,i)+i=1∑n​si​)−21​(i=1∑n​j=1∑n​si​sj​dis(i,j))=Si=1∑n​si​dis(root,i)+S2−21​i=1∑n​j=1∑n​si​sj​dis(i,j)=Si=1∑n​si​dis(root,i)+S2−i=1∑n​j=i+1∑n​si​sj​dis(i,j)​
总复杂度 O ( n l o g n ) \mathcal O(nlogn) O(nlogn)

代码

#include<cstdio>
#include<cctype>
#include<algorithm>
#include<vector>
namespace fast_IO
{
    const int IN_LEN=1000000,OUT_LEN=1000000;
    char ibuf[IN_LEN],obuf[OUT_LEN],*ih=ibuf+IN_LEN,*oh=obuf,*lastin=ibuf+IN_LEN,*lastout=obuf+OUT_LEN-1;
    inline char getchar_(){return (ih==lastin)&&(lastin=(ih=ibuf)+fread(ibuf,1,IN_LEN,stdin),ih==lastin)?EOF:*ih++;}
    inline void putchar_(const char x){if(oh==lastout)fwrite(obuf,1,oh-obuf,stdout),oh=obuf;*oh++=x;}
    inline void flush(){fwrite(obuf,1,oh-obuf,stdout);}
}
using namespace fast_IO;
#define getchar() getchar_()
#define putchar(x) putchar_((x))
#define rg register
typedef long long ll;
template <typename T> inline T max(const T a,const T b){return a>b?a:b;}
template <typename T> inline T min(const T a,const T b){return a<b?a:b;}
template <typename T> inline void mind(T&a,const T b){a=a<b?a:b;}
template <typename T> inline void maxd(T&a,const T b){a=a>b?a:b;}
template <typename T> inline T abs(const T a){return a>0?a:-a;}
template <typename T> inline void Swap(T&a,T&b){T c=a;a=b;b=c;}
template <typename T> inline T gcd(const T a,const T b){if(!b)return a;return gcd(b,a%b);}
template <typename T> inline T lcm(const T a,const T b){return a/gcd(a,b)*b;}
template <typename T> inline T square(const T x){return x*x;};
template <typename T> inline void read(T&x)
{
    char cu=getchar();x=0;bool fla=0;
    while(!isdigit(cu)){if(cu=='-')fla=1;cu=getchar();}
    while(isdigit(cu))x=x*10+cu-'0',cu=getchar();
    if(fla)x=-x;
}
template <typename T> inline void printe(const T x)
{
    if(x>=10)printe(x/10);
    putchar(x%10+'0');
}
template <typename T> inline void print(const T x)
{
    if(x<0)putchar('-'),printe(-x);
    else printe(x);
}
const int maxn=200001,maxm=400001;
int n,Q;
int head[maxn],nxt[maxm],tow[maxm],tmp;
inline void addb(const int u,const int v)
{
    tmp++;
    nxt[tmp]=head[u];
    head[u]=tmp;
    tow[tmp]=v;
}
ll SIZE;
int minn,root,son[maxn];
bool vis[maxn];
void getroot(const int u,const int fa)
{
    son[u]=1;
    int maxx=0;
    for(rg int i=head[u];i;i=nxt[i])
    {
        const int v=tow[i];
        if(v!=fa&&!vis[v])
        {
            getroot(v,u);
            son[u]+=son[v];
            maxd(maxx,son[v]);
        }
    }
    maxd(maxx,(int)SIZE-son[u]);
    if(maxx<minn)minn=maxx,root=u;
}
int ROOT,F[maxn];
std::vector<int>E[maxn];
int fr[maxn];
void solve(const int u,const int SZ,const int SON)
{
    vis[u]=1;
    for(rg int i=head[u];i;i=nxt[i])
    {
        const int v=tow[i];
        if(!vis[v])
        {
            minn=0x7fffffff,SIZE=son[v];
            if(SIZE>SON)SIZE=SZ-SON;
            getroot(v,u);
            E[u].push_back(root);
            F[root]=u,fr[root]=v;
            solve(root,SIZE,son[root]);
        }
    }
}
int rmq[maxm][21],top,fst[maxn];
ll dep[maxn];
void dfs(const int u,const int fa)
{
    rmq[++top][0]=u;
    fst[u]=top;
    for(rg int i=head[u];i;i=nxt[i])
    {
        const int v=tow[i];
        if(v!=fa)dep[v]=dep[u]+1,dfs(v,u),rmq[++top][0]=u;
    }
}
int bit[21],log_[3000000];
int MIN(const int u,const int v){return dep[u]<dep[v]?u:v;}
int lca(const int u,const int v)
{
    const int A=min(fst[u],fst[v]),B=max(fst[u],fst[v]);
    return MIN(rmq[A][log_[B-A+1]],rmq[B-bit[log_[B-A+1]]+1][log_[B-A+1]]);
}
ll dis(const int u,const int v)
{
    return dep[u]+dep[v]-(dep[lca(u,v)]<<1);
}
ll g[maxn],f[maxn],size[maxn];
ll vvv[maxn],T;
int stack[21],tot;ll sz[233];
ll calc(const int l,const int r)
{
    ll res=0;
    for(rg int i=1;i<=tot;i++)
        if(dis(stack[i],l)>dis(stack[i],r))
            res+=sz[i];
    return res;
}
ll Res(const int p)
{
    ll res=g[p];
    stack[++tot]=p;
    for(rg int i=1;i<tot;i++)res+=g[stack[i]]-f[stack[i+1]]+(size[stack[i]]-size[stack[i+1]])*dis(stack[i],p);
    return res;
}
ll qz(const int p)
{
    tot=1;
    int gg=p;
    while(gg!=ROOT)gg=F[gg],tot++;
    for(rg int i=tot,j=p;i>=1;i--,j=F[j])stack[i]=j;
    for(rg int i=1;i<tot;i++)sz[i]=size[stack[i]]-size[stack[i+1]];
    tot--;
    return Res(p);
}
inline void add(int p,const int more)
{
    const int O=p;vvv[p]+=more,size[p]+=more,SIZE+=more;
    while(p!=ROOT)
    {
        const ll R=dis(O,F[p]);
        f[p]+=R*more,g[F[p]]+=R*more;
        p=F[p];
        size[p]+=more;
    }
    T+=more*qz(O);
}
int main()
{
    bit[0]=1;
    for(rg int i=1;i<=20;i++)bit[i]=bit[i-1]<<1;
    for(rg int i=1;i<=20;i++)
        for(rg int j=bit[i];j<(bit[i]<<1);j++)
            log_[j]=i;
    read(n),read(Q);
    for(rg int i=1;i<n;i++)
    {
        int u,v;read(u),read(v);
        addb(u,v),addb(v,u);
    }
    minn=0x7fffffff,SIZE=n,getroot(1,1);
    ROOT=root;
    solve(root,SIZE,son[root]);
    dfs(1,1);
    for(rg int i=1;i<=20;i++)
        for(rg int j=1;j+bit[i]-1<=top;j++)
            rmq[j][i]=MIN(rmq[j][i-1],rmq[j+bit[i-1]][i-1]);
    SIZE=0;
    for(rg int i=1;i<=n;i++)
    {
        int x;read(x);
        add(i,x);
    }
    for(rg int i=1;i<=Q;i++)
    {
        int opt,x,y;read(opt);
        if(opt==1)read(x),read(y),y-=vvv[x],add(x,y);
        else read(x),print(SIZE*qz(x)-T+SIZE*SIZE),putchar('\n');
    }
    return flush(),0;
}

总结

和幻想乡那题差不多，还是挺清真的

zhouyuheng2003
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【高级数据结构C++】块状链表——文本编辑器 luogu p4008（指针中 引用& 的使用）
qq_73928885的博客
09-23 319
分块使用到的 **数组**结构 可以极大的加速`检索`的效率，使用 **链** 这种结构 进行`插入和删除`等修改操作 就较数组 效率更高，基于这两者各自的优势互补下，这种链表串起来的分块可以结合形成一种 检索很快，同时修改效率也很高的 高级数据结构 ：**块状链表**
【Luogu3676】小清新数据结构题（动态点分治）
小蒟蒻yyb的博客
07-16 247
题面 洛谷 题解 先扯远点，这题我第一次看的时候觉得是一个树链剖分+线段树维护。 做法大概是这样： 我们先以任意一个点为根，把当前点看成是一棵有根树。比方说以111为根。 那么，在询问以ppp为根的时候的答案，我们看看哪些子树发生了变化。 发现真正会产生变化的只有1..p1..p1..p这条链上的所有点，其它点的贡献和以111为根时的贡献是一样的。 考虑这条链上的所有点的贡献变...
洛谷P3676--小清新数据结构题
ENESAMA的博客
11-26 195
题目 今天做了一天的LINK-CUT-TREE，非常难受 晚上就只好做点小清新数据结构玩 其实晚上看了半天没看懂，机房dalao随手讲了一下我便恍然大悟 这道题就是一道很裸很裸的链剖，甚至比正常的模版还要水 但是公式十分难推 考虑换根的时候，原来的根（默认为1）到这个根路径以外的点的贡献是不变的 那么对于路径上的点的贡献，洛谷题解的第三篇就讲的很清楚了 所以就贴代码了 // l...
小清新数据结构题
10-02 117
首先我们要发现一个性质，对于每一棵树，我们换了一个根（把原本根的某个儿子\(v_1\)记成新的根） 我们记这个树的权值和为sum，每个子树的权值和为\(S[i]\)，对于每次换根，受影响的\(S[i]\)只有根本身和\(v_1\)，并且满足：\(S[rt]->sum - S[v_1]\), \(S[v_1] -> S[rt]\) 于是我们能惊人的发现：\(\sum (sum ...
[Luogu3676]小清新数据结构题
abcyan1235的博客
01-18 109
题面戳我 题意：给一棵树，树上有点权，每次操作为修改一个点的点权，或者是询问以某个点为根时，每棵子树（以每个点为根，就有n棵子树）点权和的平方和。 \(n\le2*10^5\)，保证答案在long long范围内 sol 我们设\(s_i\)表示以\(p\)为整棵树的根时，以\(i\)为根的子树的点权和。设\(Sum\)表示所有点的点权和，即\(Sum=\sum_{i=1}^{n}val...
Luogu3676: 小清新数据结构题
Cyhlnj
01-18 296
题面 传送门 题解 先来一发很显然的暴力 维护两个数组，一个是子树的val和，一个是子树的val和的平方和 暴力更新，暴力查询就可以获得10分吐槽一波luogu的部分分 # include # define RG register # define IL inline # define Fill(a, b) memset(a, b, sizeof(a)) # define S
[luogu p3601] 签到题
crab_xbc的博客
10-04 177
传送门 签到题 题目背景 这是一道签到题！ 建议做题之前仔细阅读数据范围！ 题目描述 我们定义一个函数：qiandao(x)为小于等于x的数中与x不互质的数的个数。 这题作为签到题，给出l和r，要求求\(\sum_{i=l}^r qiandao(i)~mod~666623333\)。 输入输出格式 输入格式 一行两个整数，l、r。 输出格式 一行一个整数表示答案。 输入输出样例 输入样例...
【DP】【线段树】基站选址（luogu 2605/金牌导航 数据结构优化DP-2）
ssllyf的博客
07-08 160
有若干个村庄在一条直线上，距离第一个村庄d_i，在该村庄建立基站要花费c_i，如果在离该村不大于s_i的范围内有一个基站，那么该村会被信号覆盖，如果一个村庄没有被信号覆盖，那么有w_i的代价， 现在最多建k个基站，问你最小代价
记录关于Codeforces, AtCoder, Luogu, Acwing等OJ上算法题的代码
07-03
记录关于Codeforces, AtCoder, Luogu, Acwing等OJ上算法题的代码
luogu-stats-card：动态生成洛谷个人练习数据卡片
02-05
luogu-stats-card是一个动态生成洛谷用户练习数据卡片的工具，可以展示自己的做题情况。可以用于个人主页，博客，github等可以插入图片的地方。 去做 修复获取数据错误和用户设置数据不可见的错误 增加黑暗模式 ...
Luogu P3676 小清新数据结构题
呆头呆脑没有烦恼
06-11 264
Problem 一棵有点权树，每个节点都有一个s表示其子树权值和。支持点权修改，以及查询x为根时，所有节点s的平方和。 Solution （一）考虑没有换根，即对于所有查询均有x=1 点修改u的权值，设增量为a。根据树的性质，只有path(1, u)上的点的s会被更改。 考虑这次修改对答案的贡献。 ⇒∑i∈path(1,u)(si+a)2−∑i∈path(1,u)s2i⇒∑i∈pa...
洛谷　小清新数据结构题
JH_2002的博客
08-02 271
前言 标算点分治，蒟蒻树链剖分。 题面 原题可以戳。由于表达能力过弱，所以自己不再复述题面。 sol 可能有一大堆ΣΣ\Sigma 。。 然而我并不会那么数学的符号。。。 所以全凭脑算。 在不考虑换根与修改的情况下，只要理解了题意，求解就是dfs。但由于发现修改是一个点一个点修改的，所以每次要针对一个点的修改来算出与修改前的贡献差。所以说要针对出一个点来算贡献。如果我们是按一个一个...
【Luogu 3676 小清新数据结构题】【动态点分治 + 思维题】
Kumii
12-22 381
【Luogu 3676 小清新数据结构题】【动态点分治 + 智商题】
动态点分治系列（幻想乡战略游戏、开店、小清新数据结构题）
luoyuef的博客
12-20 225
以上三道题在洛谷都能找到。总结一下就是，记录分治时的父亲。 因为是子树关系的，并不关心真实的父亲是谁，所以可以放在点分树上维护两个数组来计算信息。本文代码量超长，请谨慎食用。这道题是入门题，比较简单。幻想乡战略游戏传送门//幻想乡战略游戏 #include<bits/stdc++.h> using namespace std;const int MAXN=4e5+5; #define ll lon
Panda HDU - 4046【树状数组】【一道需要极度细心的题】
既然弱小，就只顾变强就是了
07-29 222
  很多博主说这不过是一道树状数组或者线段树的水题，可我并不这么认为，这道题让我更好的理解了关于树状数组的更新函数「uppdate ( )」，所以我觉得这是一道很不错的题，至少在了解树状数组这一块确实如此。 先发一下这题的题面吧（题面有点小清新——如果翻译成中文的话）：直接跳转到题目的传送门 （我比较的懒，所以不去看英文，直接上翻译后的文本） 问题描述 当我写下这封信时，你可能已经乘飞机去...
实时计算：Apache Flink：Flink与Kafka集成实现事件驱动架构.docx
09-02
实时计算：Apache Flink：Flink与Kafka集成实现事件驱动架构.docx
移动软件开发实验五：高校新闻
09-02
移动软件开发实验五：高校新闻
分布式存储系统：Google Cloud Storage：GoogleCloudStorage架构解析.docx
09-02
分布式存储系统：Google Cloud Storage：GoogleCloudStorage架构解析.docx
基于现有explorer文件资源管理，实现跨平台告诉多标签页文件资源管理器，类似360文件管理器等，还处于起步阶段
最新发布
09-02
基于现有explorer文件资源管理，实现跨平台告诉多标签页文件资源管理器，类似360文件管理器等，还处于起步阶段
smart_luogu
07-10
"Smart_Luogu"通常是指一个结合了智能算法和LeetCode/洛谷Online Judge平台的学习工具或辅助软件。它可能是专门为编程竞赛或解决算法题目的用户设计的一款应用，提供智能化的解题建议、代码自动补全、数据结构和算法分析等功能，帮助用户更高效地学习和提高算法水平。这类工具利用机器学习技术，可以根据用户的做题历史和习惯，给出个性化的学习路径和优化方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值