「2018山东一轮集训」 Tree

 

 

    为什么出题人这么毒瘤啊??!!一个分块还要带log的题非要出成n<=2*1e5。。。。。。。

    为了卡过最后两个点我做了无数常数优化,包括但不限于:把所有线段树改成 存差分的树状数组;把树剖求LCA的极小的log优化成rmq O(1)求LCA;根据测试情况手动调整siz的大小;

    但就是死也卡不过去,算了算了QWQ

 

(常规套路,先把1设成根建有根树)

 

    这个题的主要思路就是 对节点的下标分块,设 f[i][j] 为 第i个块内所有点到点j的距离和,然后看如何快速的动态维护这个玩意。。。。

    发现改动一条边权的时候,只有两个点分别位于这条边两侧的时候才会对它们之间的dis有影响。

    我们设p为边端点中更深的那个,那么也就是一个在p子树内,一个在子树外的才有影响。。。。

    于是我们对每个块开一个vector记录一下这个块内的点的dfs序集合,排完序之后就可以之间O(log)的查询某个块在一棵子树内/外的点数了。。。

    因为f[][]的第一维比较小,所以我们可以暴力枚举第一维,然后对第二维进行快速的修改。。。。。这时候发现第二维如果是存dfs序的话会更加方便(子树内可以直接进行区间修改),所以就改成下标代表dfs序啦。。。

   

    对于整块整块的一些点到某个点的距离,用上述方法就行啦。。。可以发现都是区间修改单点查询,所以用差分的树状数组可以快(可能还不止)4倍常数哦。。。

   

    查询零散的点对(i,j)之间的距离的话更加简单。。可以动态维护dis[i]表示i到根的距离(发现也是区间修改单点查询,所以可以类似上述整块的方法处理),答案就是dis[i]+dis[j]-2*dis[LCA(i,j)]。。。

 

    可能说起来不是很多吧qwq?但是要写一辈子啊QWQWQWQ。。。。

    (我美好的下午就这么没了QWQ)

    话说我把树剖求LCA改成rmq之后反而更慢了QWQ,这是什么鬼啊。。。。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
/*
    inside : b * derta
    outside : a * derta
     
    all -> a * derta
    inside -> (b-a) * derta
*/
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<vector>
#include<iostream>
#define ll long long
using namespace std;
#define pb push_back
const int maxn=200003,N=205;
 
inline int read(){
    int x=0; char ch=getchar();
    for(;!isdigit(ch);ch=getchar());
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
    return x;
}
 
void W(ll x){ if(x>=10) W(x/10); putchar(x%10+'0');}
 
int n,m,T,dep[maxn],siz[maxn],cl[maxn];
int F[maxn],dc,dfn[maxn],dy[maxn],son[maxn];
int bl[maxn],num,val[maxn*2],uu,vv,ww;
int hd[maxn],ne[maxn*2],to[maxn*2];
ll ans=0,f[N][maxn];
vector<int> id[N];
char s[10];
 
void add(const int &x,const int &y,const int &z){
    to[++num]=y,ne[num]=hd[x],hd[x]=num,val[num]=z;
}
 
void update(const int &T,int x,const int &y){ for(;x<=n;x+=x&-x) f[T][x]+=(ll)y;}
ll query(const int &T,int x){ ll an=0; for(;x;x-=x&-x) an+=(ll)f[T][x]; return an;}
 
void Fdfs(int x,int fa){
    F[x]=fa,siz[x]=1;
    for(int i=hd[x];i;i=ne[i]) if(to[i]!=fa){
        dep[to[i]]=dep[x]+1,Fdfs(to[i],x),siz[x]+=siz[to[i]];
        if(!son[x]||siz[to[i]]>siz[son[x]]) son[x]=to[i];
    }
}
 
void Sdfs(int x,int tp){
    dfn[x]=++dc,dy[dc]=x,cl[x]=tp;
     
    if(!son[x]) return;
     
    Sdfs(son[x],tp);
     
    for(int i=hd[x];i;i=ne[i])
        if(to[i]!=F[x]&&to[i]!=son[x]) Sdfs(to[i],to[i]);
}
 
inline int LCA(int a,int b){
    while(cl[a]!=cl[b]){
        if(dep[cl[a]]>dep[cl[b]]) a=F[cl[a]];
        else b=F[cl[b]];
    }
    return dep[a]>dep[b]?b:a;
}
 
inline int Get(int T,int x){
    return upper_bound(id[T].begin(),id[T].end(),x)-id[T].begin();
}
 
inline void Maintain(int o,int derta){
    int p=to[o*2-1];
    if(dep[p]<dep[to[o<<1]]) p=to[o<<1];
     
    update(0,dfn[p],derta),update(0,dfn[p]+siz[p],-derta);
     
    for(int i=1,a,b;i<=200;i++) if(id[i].size()){
        a=Get(i,dfn[p]+siz[p]-1)-Get(i,dfn[p]-1),b=id[i].size()-a;
        update(i,1,a*derta),update(i,dfn[p],(b-a)*derta),update(i,dfn[p]+siz[p],(a-b)*derta);
    }
}
 
inline ll calc(int qz,int p){
    ll an=0;
     
    for(int i=1;i<bl[qz];i++) an+=query(i,dfn[p]);
     
    for(int i=qz;i;i--){
        an+=query(0,dfn[i])+query(0,dfn[p])-2ll*query(0,dfn[LCA(p,i)]);
        if(bl[i]!=bl[i-1]) break;
    }
     
    return an;
}
 
inline void prework(){
    Fdfs(1,0),Sdfs(1,1);
     
    for(int i=1;i<=n;i++){
        bl[i]=(i-1)/1000+1;
        id[bl[i]].pb(dfn[i]);
    }
    for(int i=1;i<=200;i++) sort(id[i].begin(),id[i].end());
     
    for(int i=1;i<n;i++) Maintain(i,val[i<<1]);
}
 
inline void solve(){
    const int ha=n;
     
    while(m--){
        scanf("%s",s);
        if(s[0]=='m'){
            uu=read(),vv=read();
            if(T) uu^=ans,vv^=ans;
             
            Maintain(uu,vv-val[uu<<1]),val[uu<<1]=vv;
        }
        else{
            uu=read(),vv=read(),ww=read();
            if(T) uu^=ans,vv^=ans,ww^=ans;
             
            ans=calc(vv,ww)-calc(uu-1,ww);
             
            W(ans),puts(""),ans%=ha;
        }
    }
}
 
int main(){
//  freopen("tree.in","r",stdin);
//  freopen("tree.out","w",stdout);
     
    n=read(),m=read(),T=read();
 
    for(int i=1;i<n;i++){
        uu=read(),vv=read(),ww=read();
        add(uu,vv,ww),add(vv,uu,ww);
    }
     
    prework();
     
    solve();
     
    return 0;
}

 

posted @   蒟蒻JHY  阅读(299)  评论(0编辑  收藏  举报
编辑推荐:
· .NET Core GC压缩(compact_phase)底层原理浅谈
· 现代计算机视觉入门之:什么是图片特征编码
· .NET 9 new features-C#13新的锁类型和语义
· Linux系统下SQL Server数据库镜像配置全流程详解
· 现代计算机视觉入门之:什么是视频
阅读排行:
· Sdcb Chats 技术博客:数据库 ID 选型的曲折之路 - 从 Guid 到自增 ID,再到
· .NET Core GC压缩(compact_phase)底层原理浅谈
· Winform-耗时操作导致界面渲染滞后
· Phi小模型开发教程:C#使用本地模型Phi视觉模型分析图像,实现图片分类、搜索等功能
· 语音处理 开源项目 EchoSharp
点击右上角即可分享
微信分享提示