[树链剖分 可持久化线段树 垃圾数据结构题] Codechef JUNE17 #OAK Persistent oak

最新推荐文章于 2022-08-04 16:43:39 发布
最新推荐文章于 2022-08-04 16:43:39 发布
阅读量490 收藏
点赞数
分类专栏： 主席树 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014609452/article/details/73195097
版权

垃圾数据结构题

大概就是维护树上的点离最大承重还差多少
然后断掉的就是到根路径上最早的小于0的地方
断掉后 到根路径还剩的承重都要加上掉下的重量
就是一颗线段树满足区间加 区间求min

鄙视CC强行可持久化 硬上主席树标记永久化
有个trick 就是一个子树抖落之后 那么这一整棵子树也就是一段区间还原成初始值 这个很难打标记 那么就把初始版本的主席树的相应节点接过来就好了

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=100005;

struct edge{
  int u,v,next;
}G[N<<1];
int head[N],inum;
inline void add(int u,int v,int p){
  G[p].u=u; G[p].v=v; G[p].next=head[u]; head[u]=p;
}
#define V G[p].v
ll val[N];
int size[N],pre[N],clk;
int back[N];

int fat[N],top[N];

inline void dfs(int u){
  size[u]=1;
  for (int p=head[u];p;p=G[p].next)
    fat[V]=u,dfs(V),size[u]+=size[V];
}
inline void find(int u,int z){
  pre[u]=++clk; back[clk]=u; top[u]=z;
  int son=-1,maxv=0;
  for (int p=head[u];p;p=G[p].next)
    if (size[V]>maxv)
      maxv=size[son=V];
  if (son!=-1) find(son,z);
  for (int p=head[u];p;p=G[p].next)
    if (V!=son)
      find(V,V);
}

const int M=30000005;

int n,m;

namespace SEG1{
  int rt[N],ncnt;
  int ls[M],rs[M]; ll T[M],F[M];
  inline void Build(int &x,int l,int r){
    x=++ncnt;
    if (l==r){
      T[x]=val[back[l]]; return;
    }
    int mid=(l+r)>>1;
    Build(ls[x],l,mid); Build(rs[x],mid+1,r);
    T[x]=min(T[ls[x]],T[rs[x]])+F[x];
  }
  inline void Clear(int &x,int y,int z,ll tag,int l,int r,int ql,int qr){
    if (ql<=l && r<=qr){
      x=++ncnt; ls[x]=ls[z]; rs[x]=rs[z];
      F[x]=-tag; T[x]=T[z]-tag;
      return;
    }
    x=++ncnt; T[x]=T[y]; F[x]=F[y]; ls[x]=ls[y]; rs[x]=rs[y]; 
    int mid=(l+r)>>1;
    if (ql<=mid) Clear(ls[x],ls[y],ls[z],tag+F[x],l,mid,ql,qr);
    if (qr>mid) Clear(rs[x],rs[y],rs[z],tag+F[x],mid+1,r,ql,qr);
    T[x]=min(T[ls[x]],T[rs[x]])+F[x];
  }
  inline void Add(int &x,int y,int l,int r,int ql,int qr,int a){
    x=++ncnt; F[x]=F[y]; T[x]=T[y]; ls[x]=ls[y]; rs[x]=rs[y];
    if (ql<=l && r<=qr){
      F[x]+=a; T[x]+=a;
      return;
    }
    int mid=(l+r)>>1;
    if (ql<=mid) Add(ls[x],ls[y],l,mid,ql,qr,a);
    if (qr>mid) Add(rs[x],rs[y],mid+1,r,ql,qr,a);
    T[x]=min(T[ls[x]],T[rs[x]])+F[x];
  }
  ll Ret=0,W;
  inline void find(int x,int l,int r,ll tag){
    if (l==r){
      Ret=l; return;
    }
    int mid=(l+r)>>1;
    if (T[rs[x]]+F[x]+tag<W)
      find(rs[x],mid+1,r,tag+F[x]);
    else
      find(ls[x],l,mid,tag+F[x]);
  }
  inline void Query(int x,int l,int r,ll tag,int ql,int qr){
    if (ql<=l && r<=qr){
      if (!Ret && T[x]+tag<W)
    find(x,l,r,tag);
      return;
    }
    int mid=(l+r)>>1,ret=1<<30;
    if (qr>mid) Query(rs[x],mid+1,r,tag+F[x],ql,qr);
    if (ql<=mid) Query(ls[x],l,mid,tag+F[x],ql,qr);
  }
  inline int QQ(int x,int u,int w){
    W=w;
    while (u!=-1){
      Ret=0; Query(x,1,n+1,0,pre[top[u]],pre[u]);
      if (Ret) return back[Ret];
      u=fat[top[u]];
    }
    return 0;
  }
  inline void AA(int i,int s,int u,int W){
    rt[i]=rt[s];
    while (u!=-1){
      Add(rt[i],rt[i],1,n+1,pre[top[u]],pre[u],W);
      u=fat[top[u]];
    }
  }
}

namespace SEG2{
  int rt[N],ncnt;
  ll sum[M]; int ls[M],rs[M];
  inline void Build(int &x,int l,int r){
    x=++ncnt; sum[x]=0; ls[x]=rs[x]=0;
    if (l==r) return;
    int mid=(l+r)>>1;
    Build(ls[x],l,mid); Build(rs[x],mid+1,r);
  }
  inline void Add(int &x,int y,int l,int r,int t,int a){
    x=++ncnt; sum[x]=sum[y]+a; ls[x]=ls[y]; rs[x]=rs[y];
    if (l==r) return;
    int mid=(l+r)>>1;
    if (t<=mid)
      Add(ls[x],ls[y],l,mid,t,a);
    else
      Add(rs[x],rs[y],mid+1,r,t,a);
  }
  ll Ret=0;
  inline void Clear(int &x,int y,int z,int l,int r,int ql,int qr){
    if (ql<=l && r<=qr){
      Ret+=sum[y]; x=z; return;
    }
    x=++ncnt; ls[x]=ls[y]; rs[x]=rs[y]; 
    int mid=(l+r)>>1;
    if (ql<=mid) Clear(ls[x],ls[y],ls[z],l,mid,ql,qr);
    if (qr>mid) Clear(rs[x],rs[y],rs[z],mid+1,r,ql,qr);
    sum[x]=sum[ls[x]]+sum[rs[x]];
  }
}

int main(){
  int T,s,order,x,y;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(T);
  while (T--){
    read(n); read(m); val[0]=1LL<<60;
    for (int i=1;i<=n;i++)
      read(x),read(y),add(x,i,++inum),val[i]=y;
    fat[0]=-1; dfs(0); find(0,0);
    SEG1::Build(SEG1::rt[0],1,n+1);
    SEG2::Build(SEG2::rt[0],1,n+1);
    for (int i=1;i<=m;i++){
      read(s); read(order); read(x);
      if (order==1){
    read(y);
    int u=SEG1::QQ(SEG1::rt[s],x,y);
    printf("%d\n",u);
    if (u){
      x=u;
      SEG2::Ret=0;
      SEG2::Clear(SEG2::rt[i],SEG2::rt[s],SEG2::rt[0],1,n+1,pre[x],pre[x]+size[x]-1);
      ll sum=SEG2::Ret;
      SEG1::Clear(SEG1::rt[i],SEG1::rt[s],SEG1::rt[0],0,1,n+1,pre[x],pre[x]+size[x]-1);
      SEG1::AA(i,i,fat[x],sum);
    }else{
      SEG1::AA(i,s,x,-y);
      SEG2::Add(SEG2::rt[i],SEG2::rt[s],1,n+1,pre[x],y);
    }
      }else if (order==2){
    SEG2::Ret=0;
    SEG2::Clear(SEG2::rt[i],SEG2::rt[s],SEG2::rt[0],1,n+1,pre[x],pre[x]+size[x]-1);
    ll sum=SEG2::Ret;
    SEG1::Clear(SEG1::rt[i],SEG1::rt[s],SEG1::rt[0],0,1,n+1,pre[x],pre[x]+size[x]-1);
    SEG1::AA(i,i,fat[x],sum);
    printf("%d\n",sum);
      }
    }
    SEG1::ncnt=SEG2::ncnt=0;
    cl(SEG1::rt); cl(SEG2::rt);
    clk=0; cl(head); inum=0;
  }
  return 0;
}

一开始不会求min打加减标记 先写了个naive的

#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;

#define read(x) scanf("%d",&(x))

const int N=100005;
const int M=10000005;

int rt[N],ncnt;
int ls[M],rs[M],T[M],F[M];

inline void Add(int &x,int y,int l,int r,int ql,int qr,int a){
  x=++ncnt; F[x]=F[y]; T[x]=T[y]; ls[x]=ls[y]; rs[x]=rs[y];
  if (ql<=l && r<=qr){
    F[x]+=a; T[x]+=a;
    return;
  }
  int mid=(l+r)>>1;
  if (ql<=mid) Add(ls[x],ls[y],l,mid,ql,qr,a);
  if (qr>mid) Add(rs[x],rs[y],mid+1,r,ql,qr,a);
  T[x]=min(T[ls[x]],T[rs[x]])+F[x];
}
inline int Query(int x,int l,int r,int tag,int ql,int qr){
  if (ql<=l && r<=qr){
    return T[x]+tag;
  }
  int mid=(l+r)>>1,ret=1<<30;
  if (ql<=mid) ret=min(ret,Query(ls[x],l,mid,tag+F[x],ql,qr));
  if (qr>mid) ret=min(ret,Query(rs[x],mid+1,r,tag+F[x],ql,qr));
  return ret;
}

int n,m;


int main(){
  int order,l,r,x;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<=m;i++){
    read(order); read(l); read(r);
    if (order==1){
      read(x);
      Add(rt[i],rt[i-1],1,n,l,r,x);
    }else{
      rt[i]=rt[i-1];
      printf("%d\n",Query(rt[i],1,n,0,l,r));
    }
  }
  return 0;
}
里阿奴摩西
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第5章 树链剖分 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第5章 树链剖分 测试数据
【TJOI2018】 异或（可持久化01Trie+树链剖分）
Michael_GLF的博客
11-14 294
传送门 【题目分析】 可持久化Trie与主席树其实没啥太大的实现上的差别，因为一次只会插入一个串，也就只会在前一个版本的Trie上改变一条链，那么其他儿子就可以与主席树类似的操作直接继承。 那么如何判断两个版本之间是否有一个串呢？我们对每个节点记一个size，只要后一个版本该节点的size>前一个版本该节点的size，那么就一定至少有一个串经过了当前节点。 有了这个东西我们就可以直接...
[JZOJ6089]【CodeChef 2014 April Challenge】Final Battle of Chef【数据结构】【整体二分】
Never give in.
03-28 247
Description n,q,V≤100000,wi≤109n,q,V\leq 100000,w_i\leq 10^9n,q,V≤100000,wi​≤109 Solution 又是一道大数据结构 由于有一个下取整，这就导致了不同时间的修改值是不能简单的直接加在一起的。 容易发现，1操作的影响只会影响到距离不超过log的点。 这样我们很容易得到一个qlog⁡nlog⁡2Vq\log n\log...
[可持久化Trie，树链剖分]P4592
qq_66753825的博客
08-04 78
[可持久化Trie，树链剖分]P4592
Codechef June Challenge 2017 #Persistent oak -- 树链剖分+主席树
gjghfd
09-15 323
传送门每个点维护一下还能承受多少重量，线段树维护区间最小值就可以了。 如果一个子树全部折断，可以直接把初始版本的主席树接过来。代码：#include<cstdio> #include<vector> #include<cstring> #include<iostream> #include<algorithm> using namespace std; inline char nc(){
【树链剖分+可持久化线段树】CC_QUERY Observing the Tree
MEET YOU FIRST TIME
04-25 260
【题目】 CC 给定一棵nnn个点的带点权树，支持链加等差数列，求链和，回到第xxx次修改的版本。 n,m≤105n,m\leq 10^5n,m≤105 【解题思路】 练手（毒瘤）题。 没有回退操作的话就是一些基本操作了，维护一下斜率和截距就可以了。有回退的话再可持久化一下就好了。 【解题思路】 #include<bits/stdc++.h> using namespace std; ...
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
【GDOI2016】疯狂动物城（树链剖分+可持久化线段树）
一个蒟蒻的博客
08-14 522
码农题…… 调了我三个晚上…… 看来我的代码能力还是太弱了…… 首先我们不难发现在u到v这条链的答案为∑ni=1(n−i)(n−i+1)ai2∑i=1n(n−i)(n−i+1)ai2\sum_{i=1}^n\frac{(n-i)(n-i+1)a_i}{2} 然后把它拆开可以得到答案为∑ni=1(n+1)nai−(2n+1)iai+i2ai∑i=1n(n+1)nai−(2n+1)iai+i2...
Codechef 2017 March Challenge 简要题解
lych的博客
03-13 1427
在比赛进行到一半的时候才参加，，导致challenge没法搞得很好       写一个简要题解吧，，challenge太差了就不放了 Xenny and Alternating Tasks：直接按照题意模拟即可。 Bear and Extra Number：首先处理重复；否则一定是极值。 Bandwidth of a matrix：二分答案，然后贪心多放1，判断是否能合
【分治+二维偏序】CC_SUMDIS Sum of distances
MEET YOU FIRST TIME
01-31 237
【题目】 codechef 有一个nnn个点的DAG\text{DAG}DAG。 如果i≤n−1i\leq n-1i≤n−1，iii到i+1i+1i+1有一条边权为aia_iai​的有向边。 如果i≤n−2i\leq n-2i≤n−2，iii到i+2i+2i+2有一条边权为bib_ibi​的有向边。 如果i≤n−3i\leq n-3i≤n−3，iii到i+3i+3i+3有一条边权为cic_ici...
[codechef MARCH17]SUMDIS
samjia2000的博客
03-20 545
题目大意有一个一行上有n个点的图 第i个点向i+1连长度为a[i]的有向边，向i+2连长度为b[i]的有向边，向i+3连长度为c[i]的有向边 问两两间最短路长度之和 1≤n≤1051\le n\le10^5水法先来说说我的水法： 考虑从后往前枚举起点，那么设当前到i，如果在分别以i+1,i+2,i+3为起点的最短路树中x点的父亲都是一样的，那么在后来枚举的i里面x的父亲是一样的。对于这样的
冲刺NOI2017 (20) 距离 （可持久化树链剖分）
yashem66
06-16 887
题目大意给定一棵nn个点的边带权的树，以及一个排列pp，有qq个询问，给定点 l,r,kl,r,k，希望你求出： ∑点j∈l到r的最短路径dis(p[j],k)\sum_{点j\in{l到r的最短路径}}dis(p[j],k) 其中dis(u,v)dis(u,v)表示在树上uu到vv的最短路径的长度。数据范围：(n,p<=2∗105)(n,p<=2*10^5 )题解我们先抛开这个道题不谈，讨论另
Codechef CHEFFIB 点分树套树状数组
beginend
05-30 358
题意 有一棵n个节点的树，初始每个节点的权值均为0。要求资瓷q个操作： 1 u m a b表示对于任意一个节点v，若dis(u,v)≤mdis(u,v)≤mdis(u,v)\le m，则节点v的权值加上以a和b为开头的斐波那契数列的第dis(u,v)dis(u,v)dis(u,v)项。 2 u询问节点u的权值 n,q≤300000n,q≤300000n,q\le300000 分析 考虑...
CodeChef BINOMSUM
wxh010910
11-25 431
链接：link题意：有TT天，每天有KK个小时，第ii天有D+i−1D+i-1道菜，第一个小时你选择LL道菜吃，接下来每个小时你可以选择吃一道菜或者选择AA个活动中的一个参加，不能连续两个小时吃菜，问每天的方案数之和。K,AK, A预先给定，QQ次询问，每次给D,L,TD, L, T。题解：将ans=∑D+T−1i=D(iL)F(i)ans = \sum_{i=D}^{D+T-1} \binom{i
CodeChef March Challenge 2017 题解
YxuanwKeith的博客
03-13 1267
CC XENTASK由于要交替选，所以要不第一个人选位置为奇数的数，第二个人选位置为偶数的数，要不第一个人选位置为偶数的数，第二个人选位置为奇数的数。取最小值即可。#include <cstring> #include <cstdio> #include <algorithm>using namespace std;int n, sum[2][2];void solve() { memset
树链剖分详解
算法小猪的博客
08-13 1258
目录一、树链剖分相关概念1.为啥要剖分2.轻边和重边3.轻重边路径剖分的性质二、树链剖分的实现1.重链剖分 一、树链剖分相关概念 1.为啥要剖分 1.可以维护树路径上的信息(维护) 2.将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)O(logN)O(logN)。(复杂度低) 2.轻边和重边 将树中的边分为：轻边和重(zhong)边 定义size(x)size(x)size(x)为以xxx为根的子树的节点个数。 令vvv为xxx的儿子节点中sizesizesize值最大的节点，那么边(
Aragorn 树链剖分
最新发布
09-24
Aragorn 树链剖分是一种将一棵树剖分为若干条链的算法，然后利用数据结构去维护每一条链的技术。剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值