树上操作 解题报告

最新推荐文章于 2022-07-20 16:54:21 发布
最新推荐文章于 2022-07-20 16:54:21 发布
阅读量898 收藏
点赞数
分类专栏： BIT 前缀和 文章标签： BIT 差分 前缀和 dfs序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TA201314/article/details/46832607
版权

两种操作：
1.输入X,s,t，对于链s-t，设上面的点为 v1,..,k ，给 vi 加上 iXRi 。
2.输入s,t，询问链s-t的权值和，对100711433取模。
所有操作1的R相同，在一开始会给出。
所以操作1在操作2之后出现，操作1有U个，操作2有Q个。
1≤n,Q,U≤105,1≤R,X≤109
时限1.5s，空间限制256MB。

想出标算的时候就剩1个半小时了，然后自不量力开始码标算，然后开始各种推错式子，最后还是交了暴力，结果暴力爆零了。
原因是因为暴力用dfs序对付了询问，结果bit的时候把n<<1写成了1 << n；然后试了几组小数据没有问题，大数据就吃翔了。

标算的话。。既然修改和询问是分开的，也就是说如果我们能先把每个点的点权搞出来，然后就可以直接上dfs序+bit了。
那么问题在于修改的贡献该如何累积，注意这个式子 XiRi ,它本身虽然不太好求，但它的前缀我们是回求的，那我们求一下前缀然后差分一下就好了。

令Sn=∑i=1nXiRi
，则
RSn=∑i=1nXiRi+1
,
(1−R)Sn=∑i=1nXRi−XRn+1=XR(Rn−1)R−1−nRn+1
(R−1)Sn=XnRn+1−XRn+1R−1−XRR−1
Sn=RR−1(XnRn−1R−1XRn−XRR−1)

然后显然可以就可以维护 ∑XiaiRai 和 ∑XiRai ，我一开始想的是维护当前的和前一个的然后求点权的时候再减，但后来发现（写起来太吃屎了）其实反正都有什么分配律什么的，直接维护差分后的就行。
因为这是区间修改、单点查询，所以我们考虑差分序列。搞出原树的重链，然后把每一个修改对于每一条链打一个载入标记和一个载出标记；注意到因为一个修改需要先上去再下去走两遍，所以要打两遍标记。因为一条链只会跨过 log2n 的重链，所以这样做的时间复杂度是 O(nlog2n) 的。
打完标记以后就是说我们需要面对这样一个事情，知道当前的 ∑XiaiRai 和 ∑XiRai ，怎么求 ∑Xi(ai+1)Rai+1 和 ∑XiRai+1 ?显然， ∑XiRai+1 = R∑XiRai , ∑Xi(ai+1)Rai+1=R∑XiaiRai+∑XiaiRai+1 ,这样我们就以搞了。
但是还有一个问题，注意到分母上出现了R-1，那么就要求R-1有逆元，可如果R-1没有逆元怎么办？100711433是个质数，所以R-1没有逆元，当且仅当 R−1=0(mod 100711433) ，也就是 R=1(mod 100711433) ，所以我们需要单独处理这种蛋疼的情况，显然这时
Sn=Xn∗(n+1)2=X12(n2+n)
，所以基本一样，只要维护 ∑Xia2i 和 ∑Xiai 即可，然后因为差分了，所以 ∑Xiai 其实不会变， ∑Xi(ai+1)2=∑Xia2i+2∑Xiai 后面的1差分掉了。

然后。。总时间复杂度 O(nlog2n) 思路还算尚可，代码就直接吃翔了。
代码（暴力）：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
using namespace std;
#define Mod 100711433
char * cp=(char *)malloc(10000000);
inline void in(int &x){
    while(*cp<'0'||*cp>'9')++cp;
    x=0;
    while(*cp>='0'&&*cp<='9')x=x*10+(*cp++^'0');
}
int ptr[100005],succ[200005],next[200005],etot=1;
inline void addedge(int u,int v){
    next[etot]=ptr[u],ptr[u]=etot,succ[etot++]=v;
}
int fa[100005][18],depth[100005],bl[100005],br[100005],btot=1;
void dfs(int node){
    depth[node]=depth[fa[node][0]]+1;
    bl[node]=btot++;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=fa[node][0]){
            fa[succ[i]][0]=node;
            for(int j=1;j<18;++j)fa[succ[i]][j]=fa[fa[succ[i]][j-1]][j-1];
            dfs(succ[i]);
        }
    br[node]=btot++;
}
int path[100005];
typedef long long LL;
LL fac[100005];
int p[100005];
int n;
int bit[200005];
void add(int x,int A){
    for(;x<=1<<n;x+=x&-x)bit[x]=(bit[x]+A)%Mod;
}
int query(int x){
    int ans=0;
    for(;x;x-=x&-x)ans=(ans+bit[x])%Mod;
    return ans;
}
int main(){
    freopen("tree.in","r",stdin);
    freopen("tree_50.out","w",stdout);
    fread(cp,1,10000000,stdin);
    int U,Q,R,i;
    in(n),in(R);
    fac[0]=1;
    for(i=1;i<=n;++i)fac[i]=fac[i-1]*R%Mod;
    int u,v;
    for(i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }
    in(U),in(Q);
    int root=(rand()<<16|rand())%n+1;
    dfs(root);
    int s,t,ptot,X;
    while(U--){
        in(X),in(s),in(t);
        u=s,v=t;
        ptot=0;
        while(u!=v)
            if(depth[u]>depth[v]){
                path[ptot++]=u;
                u=fa[u][0];
            }
            else v=fa[v][0];
        path[ptot++]=u;
        v=t;
        ptot+=depth[v]-depth[u];
        for(;u!=v;v=fa[v][0])path[--ptot]=v;
        ptot+=depth[t]-depth[u];
        for(i=0;i<ptot;++i)p[path[i]]=(p[path[i]]+X*fac[i+1]%Mod*(i+1)%Mod)%Mod;
    }
    for(i=n;i;--i)add(bl[i],p[i]),add(br[i],-p[i]);
    int ans;
    while(Q--){
        in(s),in(t);
        ans=(query(bl[s])+query(bl[t]))%Mod;
        if(depth[s]>depth[t])swap(s,t);
        for(i=18;i--;)
            if(1<<i&depth[t]-depth[s])
                t=fa[t][i];
        for(i=18;i--;)
            if(fa[s][i]!=fa[t][i])
                s=fa[s][i],t=fa[t][i];
        if(s!=t)s=fa[s][0];
        ans=((ans-(query(bl[s])+query(bl[fa[s][0]]))%Mod)%Mod+Mod)%Mod;
        printf("%d\n",ans);
    }
}

代码（标算）：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
#include<cstdlib>
#define Mod 100711433
char * cp=(char *)malloc(10000000);
int ptr[100005],succ[200005],next[200005],etot=1;
inline void in(int &x){
    while(*cp<'0'||*cp>'9')++cp;
    x=0;
    while(*cp>='0'&&*cp<='9')x=x*10+(*cp++^'0');
}
inline void addedge(int u,int v){
    next[etot]=ptr[u],ptr[u]=etot,succ[etot++]=v;
}
typedef long long LL;
inline int pow(int a,int b){
    LL ans=1,t=a;
    for(;b;b>>=1,t=t*t%Mod)
        if(b&1)
            ans=ans*t%Mod;
    return ans;
}
LL sr[100005],sir[100005];//R≠1
LL sum2[100005],sum1[100005];
int fa[100005],size[100005],depth[100005],maxson[100005],top[100005];
void sizedfs(int node){
    depth[node]=depth[fa[node]]+1;
    size[node]=1;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=fa[node]){
            fa[succ[i]]=node;
            sizedfs(succ[i]);
            size[node]+=size[succ[i]];
        }
}
int bl[100005],br[100005],btot=1;
LL bit[200005];
void builddfs(int node,int wt){
    top[node]=wt;
    bl[node]=btot++;
    for(int i=ptr[node];i;i=next[i])
        if(succ[i]!=fa[node]&&size[succ[i]]>size[maxson[node]])
            maxson[node]=succ[i];
    if(maxson[node]){
        builddfs(maxson[node],wt);
        for(int i=ptr[node];i;i=next[i])
            if(succ[i]!=maxson[node]&&succ[i]!=fa[node])
                builddfs(succ[i],succ[i]);
    }
    br[node]=btot++;
}
int p[100005],s[100005],t[100005],X[100005],lca[100005];
LL fac[100005];
inline LL multi(int x){
    return (LL)x*x%Mod;
}
LL nowsr,nowsir;//R≠1
LL nowsum2,nowsum1;
int niyuan;
inline void add1(int node,int dis,int X){
    sum2[node]=(sum2[node]+(multi(dis)-multi(dis-1))%Mod*X%Mod)%Mod;
    sum1[node]=(sum1[node]+X)%Mod;
    //cout<<"Add:"<<node<<","<<dis<<","<<X<<"->"<<sum2[node]<<" "<<sum1[node]<<endl;
}
inline void minus1(int node,int dis,int X){
    sum2[node]=(sum2[node]-(multi(dis)-multi(dis-1))%Mod*X%Mod)%Mod;
    sum1[node]=(sum1[node]-X)%Mod;
    //cout<<"Minus:"<<node<<","<<dis<<","<<X<<"->"<<sum2[node]<<" "<<sum1[node]<<endl;
}
inline void update1(int node){
    nowsum2=(nowsum2+(nowsum1<<1))%Mod;
    nowsum2=(nowsum2+sum2[node])%Mod;
    nowsum1=(nowsum1+sum1[node])%Mod;
    p[node]=(p[node]+(nowsum2+nowsum1)%Mod*niyuan%Mod)%Mod;
    //cout<<"Update:"<<node<<":"<<nowsum2<<","<<nowsum1<<"->"<<p[node]<<endl;
}
inline void add(int node,int dis,int X){
    sum2[node]=(sum2[node]+(dis*fac[dis]%Mod-(dis-1)*fac[dis-1]%Mod)%Mod*X%Mod)%Mod;
    sum1[node]=(sum1[node]+(fac[dis]-fac[dis-1])%Mod*X%Mod)%Mod;
    //cout<<"Add:"<<node<<","<<dis<<","<<X<<"->"<<sum2[node]<<","<<sum1[node]<<" "<<fac[dis]%Mod*X%Mod<<endl;
}
inline void minu(int node,int dis,int X){
    sum2[node]=(sum2[node]-(dis*fac[dis]%Mod-(dis-1)*fac[dis-1]%Mod)%Mod*X%Mod)%Mod;
    sum1[node]=(sum1[node]-(fac[dis]-fac[dis-1])%Mod*X%Mod)%Mod;
    //cout<<"Minus:"<<node<<","<<dis<<","<<X<<"->"<<sum2[node]<<","<<sum1[node]<<" "<<fac[dis]%Mod*X%Mod<<endl;
}
inline void update(int node){
    nowsum1=nowsum1*fac[1]%Mod;
    nowsum2=(nowsum2*fac[1]%Mod+nowsum1)%Mod;
    nowsum2=(nowsum2+sum2[node])%Mod;
    nowsum1=(nowsum1+sum1[node])%Mod;
    p[node]=(p[node]+(nowsum2-nowsum1*niyuan)%Mod*fac[1]%Mod*niyuan)%Mod;
    //cout<<"Update:"<<node<<":"<<nowsum2<<","<<nowsum1<<"->"<<p[node]<<endl;
}
int n;
inline void badd(int x,int A){
    for(;x<=n<<1;x+=x&-x)bit[x]=(bit[x]+A)%Mod;
}
inline int bQ(int x){
    int ans=0;
    for(;x;x-=x&-x)ans=(ans+bit[x])%Mod;
    return ans;
}
int main(){
    freopen("tree.in","r",stdin);
    freopen("tree.out","w",stdout);
    fread(cp,1,10000000,stdin);
    int i,j,u,v,R;
    in(n),in(R);
    R%=Mod;
    fac[0]=1;
    for(i=1;i<=n;++i)fac[i]=fac[i-1]*R%Mod;
    for(i=n;--i;){
        in(u),in(v);
        addedge(u,v),addedge(v,u);
    }
    int root=(rand()<<16|rand())%n+1;
    sizedfs(root);
    builddfs(root,root);
    int U,Q;
    in(U),in(Q);
    //搞出p[i]
    for(i=U;i--;){
        in(X[i]),in(s[i]),in(t[i]);
        u=s[i],v=t[i];
        while(top[u]!=top[v])
            if(depth[top[u]]>depth[top[v]])u=fa[top[u]];
            else v=fa[top[v]];
        if(depth[u]>depth[v])lca[i]=v;
        else lca[i]=u;
    }
    if(R==1)niyuan=pow(2,Mod-2);
    else niyuan=pow(R-1,Mod-2);
    int node;
    if(R==1){
        //上去。(包含lca)
        for(i=U;i--;){
            for(u=s[i];top[u]!=top[lca[i]];u=fa[top[u]])add1(u,depth[s[i]]-depth[u]+1,X[i]);
            add1(u,depth[s[i]]-depth[u]+1,X[i]);
            if(lca[i]!=top[lca[i]])minus1(fa[lca[i]],depth[s[i]]-depth[lca[i]]+2,X[i]);
        }
        for(i=n;i;--i)
            if(maxson[i]==0){
                nowsum2=nowsum1=0;
                for(node=i;top[node]==top[i];node=fa[node])update1(node);
            }
        /*for(i=1;i<=n;++i)cout<<p[i]<<" ";
        cout<<endl;*/
        //cout<<"-------------\n";
        //下来 
        memset(sum2,0,sizeof(sum2));
        memset(sum1,0,sizeof(sum1));
        for(i=U;i--;){
            for(v=t[i];top[v]!=top[lca[i]];v=fa[top[v]]){
                add1(top[v],depth[top[v]]-depth[lca[i]]+depth[s[i]]-depth[lca[i]]+1,X[i]);
                if(maxson[v])minus1(maxson[v],depth[v]-depth[lca[i]]+depth[s[i]]-depth[lca[i]]+2,X[i]);
            }
            if(v!=lca[i]&&maxson[lca[i]]){
                add1(maxson[lca[i]],depth[s[i]]-depth[lca[i]]+2,X[i]);
                if(maxson[v])minus1(maxson[v],depth[s[i]]-depth[lca[i]]+depth[v]-depth[lca[i]]+2,X[i]);
            }
        }
        for(i=n;i;--i)
            if(top[i]==i){
                nowsum2=nowsum1=0;
                for(node=i;node;node=maxson[node])update1(node);
            }
        /*for(i=1;i<=n;++i)cout<<p[i]<<" ";
        cout<<endl;*/
    }
    else{
        //上去。（包含lca)
        for(i=U;i--;){
            for(u=s[i];top[u]!=top[lca[i]];u=fa[top[u]])add(u,depth[s[i]]-depth[u]+1,X[i]);
            add(u,depth[s[i]]-depth[u]+1,X[i]);
            if(top[lca[i]]!=lca[i])minu(fa[lca[i]],depth[s[i]]-depth[lca[i]]+2,X[i]);
        }
        for(i=n;i;--i)
            if(maxson[i]==0){
                nowsum2=nowsum1=0;
                for(node=i;top[node]==top[i];node=fa[node])update(node);
            }
        //下来.不包含lca。 
        //cout<<"----------\n";
        memset(sum2,0,sizeof(sum2));
        memset(sum1,0,sizeof(sum1));
        for(i=U;i--;){
            for(v=t[i];top[v]!=top[lca[i]];v=fa[top[v]]){
                add(top[v],depth[top[v]]-depth[lca[i]]+depth[s[i]]-depth[lca[i]]+1,X[i]);
                if(maxson[v])minu(maxson[v],depth[v]-depth[lca[i]]+depth[s[i]]-depth[lca[i]]+2,X[i]);
            }
            if(v!=lca[i]&&maxson[lca[i]]){
                add(maxson[lca[i]],depth[s[i]]-depth[lca[i]]+2,X[i]);
                if(maxson[v])minu(maxson[v],depth[s[i]]-depth[lca[i]]+depth[v]-depth[lca[i]]+2,X[i]);
            }
        }
        for(i=n;i;--i)
            if(top[i]==i){
                nowsum2=nowsum1=0;
                for(node=i;node;node=maxson[node])update(node);
            }
    }
    for(i=n;i;--i){
        p[i]=(p[i]+Mod)%Mod;
        badd(bl[i],p[i]),badd(br[i],-p[i]);
    }
    //回答询问 
    LL ans=0;
    while(Q--){
        in(u),in(v);
        ans=(bQ(bl[u])+bQ(bl[v]))%Mod;
        while(top[u]!=top[v])
            if(depth[top[u]]>depth[top[v]])u=fa[top[u]];
            else v=fa[top[v]];
        if(depth[u]>depth[v])swap(u,v);
        ans=((ans-bQ(bl[u])-bQ(bl[fa[u]]))%Mod+Mod)%Mod;
        printf("%d\n",ans);
    }
}

总结：
①以后比赛还剩个15min或20min的时候一定不要再写了，一定要给目前写出来的要交的程序出数据：出小数据、卡下界，出特殊数据、比如说链什么的，然后出一些可以手算的和随机的大数据。
②推式子的时候一定要仔细！
③一定要擅长使用函数，让代码和思路更清晰。

TA201314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[HAOI2015]树上操作
Q755100802的博客
12-12 347
题目描述 有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个操作，分为三种： 操作 1 ：把某个节点 x 的点权增加 a 。 操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。 操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。 输入格式 第一行包含两个整数 N, M 。表示点数和操作数。 接下来一行 N 个整数，表示树中...
poj：我在poj上的解题报告
02-12
【标题】：“poj：我在poj上的解题报告” 【描述】：“poj是我进行算法练习和提高编程技能的重要平台。在这个解题报告中，我将分享在poj上解决各类问题的心得体会，以及如何运用Java语言来解决这些算法问题。” ...
树上操作
dizong4589的博客
09-15 175
题目描述 思路 树链剖分更新子树x，由于线段树节点的顺序由dfs产生，所以更新的线段树区间为[dfn[x], dfn[x] + size[x] - 1] 代码 #include <cstdio> #include <cstring> #define lc k<<1 #define rc k<<1|1 const int MAX = 1e...
POJ 部分题解 解题报告
09-17
10. **POJ 2528 线段树.txt**：这是第三个线段树相关的题目，解题报告可能会深入讲解线段树在不同场景下的应用。 通过阅读这些解题报告，你可以学习到各种高级算法的应用，如动态规划、搜索算法、数据结构（如线段...
NOIP树链剖分习题讲解报告
最新发布
11-01
树链剖分是一种数据结构技术，它能够有效地处理树上的动态查询问题。树链剖分的核心思想是将树拆分成多个链，这样就可以通过线段树等数据结构快速查询链上的信息。具体步骤如下： 1. **预处理：** 进行DFS遍历树，...
Atlantis解题报告
10-08
在本篇解题报告中，我们将深入探讨"Atlantis"这一题目，重点解析其涉及到的线段树（Segment Tree）和离散化（Discretization）技术。线段树是数据结构中的一个重要工具，用于高效地处理区间或段上的查询与更新操作。...
北京大学_POJ_ACM解题报告
12-11
这份解题报告涵盖了POJ平台上的多种问题，涉及到的算法和编程知识点广泛，包括但不限于以下内容： 1. **基础算法**：如排序（快速排序、归并排序、冒泡排序、插入排序等）、搜索（二分查找、深度优先搜索、广度优先...
树上操作(边分治)
m0_58381738的博客
04-29 600
今天我们浅谈一下树上操作的边分治，首先我们要了解一下什么是边分治。 边分治是指在给定的一个图中，找到一条边，将这条边删去，使得删去这条边后分成的两个图的大小尽可能相等。 边分治和点分治所解决的问题基本上是相同的，但是基于边的分治只需要考虑两棵子树，所以设计算法更为简单。 ...
重链剖分链加与极值
汤键的博客
07-20 241
重链剖分链加与极值
树上操作 --- 树链剖分 + 线段树
笑面蘑菇的博客
07-30 586
传送门:洛谷2590 题目描述 一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。 我们将以下面的形式来要求你对这棵树完成一些操作： I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和 注意：从点u到点v的路径上的节点包括u和v...
5848. 树上的操作
weixin_44560620的博客
09-05 180
给你一棵 n 个节点的树，编号从 0 到 n - 1 ，以父节点数组 parent 的形式给出，其中 parent[i] 是第 i 个节点的父节点。树的根节点为 0 号节点，所以 parent[0] = -1 ，因为它没有父节点。你想要设计一个数据结构实现树里面对节点的加锁，解锁和升级操作。 数据结构需要支持如下函数： Lock：指定用户给指定节点 上锁 ，上锁后其他用户将无法给同一节点上锁。只有当节点处于未上锁的状态下，才能进行上锁操作。 Unlock：指定用户给指定节点 解锁 ，只有当指定节点当前正被
bzoj 4034: [HAOI2015]树上操作 （树链剖分）
clover_hxy的博客
12-30 679
4034: [HAOI2015]树上操作 Time Limit: 10 Sec  Memory Limit: 256 MB Submit: 3553  Solved: 1118 [Submit][Status][Discuss] Description 有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个 操作，分为三种： 操作 1 ：把某个节点 x 的点权增加
洛谷 P3178 [HAOI2015]树上操作（树链剖分）
Dawn_LLLLLLL
06-28 231
传送门 裸的树链剖分。。 不会的同学可以戳这。。 我觉得可以直接上代码。。 这次并没有动态开点。。 Code: #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #define ll long long struct node{int y,next;}a[200010]; struct tree{int l,r,lc,rc;ll c...
C++进阶：线段树与区间操作解题指南
这里的操作包括Clrd指令，用于将特定位置的元素加到所有元素上，以及Qlr指令，询问给定区间内所有元素的最大公约数。这个问题不仅要求理解线段树的应用，还需要涉及离线前缀和（prefix sum）和最大公约数的计算。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值