bzoj3083 遥远的国度 && bzoj3626 LCA （树链剖分）

今早刷了两道树剖的题目，用时两小时十五分钟= =

树剖的题目代码量普遍120+

其实打熟练之后是很容易调的，不熟练的话代码量大可能会因为某些小细节调很久

3083：裸树剖+“换根”

所谓换根其实只要判断一下当前询问点的子树和当前根的位置关系就好了，不能真的换根

根不在当前点的子树中则不影响；根在当前子树中，那么根所在的那部分子树不询问就可以了，而其他点都要询问

3626：这个题目很巧妙

有两个地方是很神的，一是将询问l~r转化为询问z一个点，二是离线操作O(qlog2n)就解决了询问

 //bzoj3083
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #define INF 1000000010
 using namespace std;
 ;
 struct node{
     int l,r,lz,mn;
 }t[maxn*];
 struct edge{
     int to,next;
 }e[maxn*];
 ,v0[maxn],opt;

 void insert(int u, int v){
     e[++tot].to=v; e[tot].next=head[u]; head[u]=tot;
 }

 void dfs1(int u, int f, int d){
     size[u]=; fa[u]=f; dep[u]=d;
     ; i=e[i].next){
         int v=e[i].to; if (v==f) continue;
         dfs1(v,u,d+);
         size[u]+=size[v];
         if (!son[u] || size[v]>size[son[u]]) son[u]=v;
     }
 }

 void dfs2(int u, int num){
     top[u]=num; tree[u]=++cnt; pre[cnt]=u;
     if (!son[u]) return;
     dfs2(son[u],num);
     ; i=e[i].next)
         if (e[i].to!=fa[u] && e[i].to!=son[u]) dfs2(e[i].to,e[i].to);
 }

 void pushup(int x){
     t[x].mn=min(t[x<<].mn,t[x<<|].mn);
 }

 void pushdown(int x){
     if (t[x].lz){
         t[x<<].lz=t[x<<|].lz=t[x].lz;
         t[x<<].mn=t[x<<|].mn=t[x].mn;
         t[x].lz=;
     }
 }

 void update(int a, int b, int w, int x){
     int l=t[x].l, r=t[x].r;
     if (l==a && r==b){
         t[x].lz=;
         t[x].mn=w;
         return;
     }
     ;
     pushdown(x);
     |);
     );
     ),update(mid+,b,w,x<<|);
     pushup(x);
 }

 int get_min(int a, int b, int x){
     int l=t[x].l, r=t[x].r;
     if (l==a && b==r) return t[x].mn;
     ;
     pushdown(x);
     );
     |);
     ),get_min(mid+,b,x<<|));
 }

 void build(int l, int r, int x){
     t[x].l=l, t[x].r=r;
     if (l==r){
         t[x].mn=v0[pre[l]];
         t[x].lz=;
         return;
     }
     ;
     );
     ,r,x<<|);
     pushup(x);
 }

 void change(int x, int y, int c){
     while (top[x]!=top[y]){
         if (dep[x]<dep[y]) swap(x,y);
         update(tree[top[x]],tree[x],c,);
         x=fa[top[x]];
     }
     if (dep[x]>dep[y]) swap(x,y);
     update(tree[x],tree[y],c,);
 }

 int main(){
     scanf(; memset(head,-,;
     ; i<n; i++) scanf("%d%d", &u, &v),insert(u,v),insert(v,u);
     dfs1(,,);
     dfs2(,);
     ; i<=n; i++) scanf("%d", &v0[i]);
     build(,cnt,);
     scanf("%d", &cap);
     while (Q--){
         scanf("%d", &opt);
         ) scanf("%d", &cap);
         ){
             scanf("%d%d%d", &u, &v, &w);
             change(u,v,w);
         }
         ){
             scanf("%d", &u);
             ].mn);
             else{
                 ;
                 ; i=e[i].next){
                     int v=e[i].to;
                     if (v==fa[u]) continue;
                     ) child=v;
                 }
                 if (child){
                     ,tree[child]-,));
                     int right=INF;
                     ));
                     printf()));
                 }
                 ,));
             }
         }
     }
     ;
 }

 //bzoj3626
 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #define MOD 201314
 using namespace std;
 ;
 struct node{
     int l,r,lz,sum,len;
 }t[maxn*];
 struct edge{
     int to,next;
 }e[maxn*];
 struct Ans{
     int z,R,L;
 }ans[maxn];
 struct cover{
     int p,id;
     bool flag;
 }a[maxn*];
 int fa[maxn],dep[maxn],size[maxn],top[maxn],son[maxn],head[maxn],tot,cnt;
 int tree[maxn],pre[maxn],n,q,u,v;

 bool cmp(cover a, cover b){
     return a.p<b.p;
 }

 void insert(int u, int v){
     e[++tot].to=v; e[tot].next=head[u]; head[u]=tot;
 }

 void dfs1(int u, int f, int d){
     fa[u]=f; dep[u]=d; size[u]=;
     ; i=e[i].next){
         int v=e[i].to; if (v==f) continue;
         dfs1(v,u,d+);
         size[u]+=size[v];
         if (!son[u] || size[v]>size[son[u]]) son[u]=v;
     }
 }

 void dfs2(int u, int num){
     top[u]=num; tree[u]=++cnt; pre[cnt]=u;
     if (!son[u]) return;
     dfs2(son[u],num);
     ; i=e[i].next)
         if (e[i].to!=son[u] && e[i].to!=fa[u]) dfs2(e[i].to,e[i].to);
 }

 void pushup(int x){
     t[x].sum=t[x<<].sum+t[x<<|].sum;
 }

 void pushdown(int x){
     if (t[x].lz){
         t[x<<].lz+=t[x].lz;
         t[x<<|].lz+=t[x].lz;
         t[x<<].sum+=t[x<<].len*t[x].lz;
         t[x<<|].sum+=t[x<<|].len*t[x].lz;
         t[x].lz=;
     }
 }

 int query(int a, int b, int x){
     int l=t[x].l, r=t[x].r;
     if (l==a && r==b) return t[x].sum;
     ;
     pushdown(x);
     );
     |);
     )+query(mid+,b,x<<|);
 }

 void update(int a, int b, int x){
     int l=t[x].l, r=t[x].r;
     if (l==a && r==b){
         t[x].sum+=t[x].len;
         t[x].lz++;
         return;
     }
     ;
     pushdown(x);
     );
     |);
     ),update(mid+,b,x<<|);
     pushup(x);
 }

 void build(int l, int r, int x){
     t[x].l=l, t[x].r=r; t[x].len=r-l+;
     if (l==r){
         t[x].sum=;
         t[x].lz=;
         return;
     }
     ;
     );
     ,r,x<<|);
     pushup(x);
 }

 void tree_update(int x, int y){
     while (top[x]!=top[y]){
         if (dep[x]<dep[y]) swap(x,y);
         update(tree[top[x]],tree[x],);
         x=fa[top[x]];
     }
     if (dep[x]>dep[y]) swap(x,y);
     update(tree[x],tree[y],);
 }

 int tree_query(int x, int y){
     ;
     while (top[x]!=top[y]){
         if (dep[x]<dep[y]) swap(x,y);
         ret+=query(tree[top[x]],tree[x],); ret%=MOD;
         x=fa[top[x]];
     }
     if (dep[x]>dep[y]) swap(x,y);
     ) % MOD +ret) % MOD;
 }

 int main(){
     scanf("%d%d", &n, &q);
     tot=; memset(head,-,sizeof(head));
     ; i<n; i++){
         scanf("%d", &u);
         insert(u,i);
     }
     cnt=;
     dfs1(,,);
     dfs2(,);
     build(,n,);
     cnt=;
     ; i<=q; i++){
         scanf("%d%d%d", &u, &v, &ans[i].z);
         a[++cnt].p=u-; a[cnt].id=i; a[cnt].flag=;
         a[++cnt].p=v; a[cnt].id=i; a[cnt].flag=;
     }
     sort(a+,a++cnt,cmp);
     ;
     ; i<=cnt; i++){
         while (now<a[i].p){
             now++;
             tree_update(now,);
         }
         int pos=a[i].id;
         );
         );
     }
     ; i<=q; i++) printf("%d\n", (ans[i].R-ans[i].L+MOD)%MOD);
     ;
 }