jzoj5865 假期旅行 线段树+倍增

本文深入探讨了深度学习与数据结构的融合应用,通过利用线段树和倍增技巧解决复杂问题,展示了解决实际场景中难题的有效方法。详细介绍了算法的核心思想、实现步骤以及代码细节,旨在提升读者在处理类似问题时的编程能力。

Description


这里写图片描述

Solution


看了题解才知道啥是ISIJ,infleaking好强啊%%%

记a[i]为从i往右走不换座位能走到的最右端。我们离线然后合并同一座位相交的线段,用线段树维护一下这个a
可以发现i向a[i]连边组成了一棵树,于是问题变成求两个点的深度差,这个用倍增做就行了

Code


#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define fill(x,t) memset(x,t,sizeof(x))
#define rep(i,st,ed) for (register int i=st;i<=ed;++i)
#define drp(i,st,ed) for (register int i=st;i>=ed;--i)
#define fi first
#define se second

typedef std:: pair <int,int> pair;
const int N=200005;

std:: vector <pair> vec[N];

int max[N<<2],tag[N<<2];
int fa[19][N];

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void cmax(int &x,int y) {
    (y>x)?(x=y):(0);
}

void push_down(int now) {
    if (!tag[now]) return ;
    int w=tag[now]; tag[now]=0;
    cmax(tag[now<<1],w); cmax(tag[now<<1|1],w);
    cmax(max[now<<1],w); cmax(max[now<<1|1],w);
}

void modify(int now,int tl,int tr,int l,int r,int v) {
    if (tl==l&&tr==r) {
        cmax(tag[now],v);
        cmax(max[now],v);
        return ;
    }
    push_down(now);
    int mid=(tl+tr)>>1;
    if (r<=mid) modify(now<<1,tl,mid,l,r,v);
    else if (l>mid) modify(now<<1|1,mid+1,tr,l,r,v);
    else {
        modify(now<<1,tl,mid,l,mid,v);
        modify(now<<1|1,mid+1,tr,mid+1,r,v);
    }
    max[now]=std:: max(max[now<<1],max[now<<1|1]);
}

int query(int now,int tl,int tr,int x) {
    if (tl==tr) return max[now];
    int mid=(tl+tr)>>1;
    push_down(now);
    if (x<=mid) return query(now<<1,tl,mid,x);
    return query(now<<1|1,mid+1,tr,x);
}

int main(void) {
    freopen("trip.in","r",stdin);
    freopen("trip.out","w",stdout);
    int n=read(),m=read(),k=read();
    rep(i,1,m) {
        int s=read(),t=read()-1,a=read();
        vec[a].push_back(pair(s,t));
    }
    rep(i,1,k) {
        std:: sort(vec[i].begin(),vec[i].end());
        int L=0,R=-1;
        for (int j=0;j<vec[i].size();++j) {
            if (vec[i][j].fi<=R+1) {
                R=std:: max(R,vec[i][j].se);
                continue;
            }
            modify(1,0,n,R+1,vec[i][j].fi-1,vec[i][j].fi);
            L=vec[i][j].fi; R=vec[i][j].se;
        }
        modify(1,0,n,R+1,n,n);
    }
    rep(i,1,n-1) {
        int tmp=query(1,0,n,i);
        if (!tmp) tmp=n+1;
        fa[0][i]=tmp;
    }
    fa[0][n]=n; fa[0][n+1]=n+1;
    rep(j,1,18) drp(i,n+1,1) {
        fa[j][i]=fa[j-1][fa[j-1][i]];
    }
    for (int T=read();T--;) {
        int x=read(),y=read(),ans=0;
        drp(i,18,0) (fa[i][x]<y)?(x=fa[i][x],ans+=(1<<i)):0;
        x=fa[0][x]; ans++;
        if (x==n+1||x<y) puts("-1");
        else printf("%d\n", ans);
    }
    return 0;
}
<think>我们使用树链剖分(重链剖分)将树分割成链,然后利用DFS序(实际上是剖分后的DFS序)将树结构转化为线性序列,然后使用线段树维护序列上的权值。这样,子树查询就转化为区间查询,节点更新就转化为单点更新。 树链剖分的DFS序:在剖分DFS中,我们优先遍历重儿子,这样保证重链上的节点在DFS序中是连续的。同时,每个子树在DFS序中也是连续的(因为DFS遍历子树时是连续的)。因此,子树查询可以转化为区间查询。 步骤: 1. 第一次DFS:计算每个节点的父节点、深度、重儿子、子树大小。 2. 第二次DFS:确定DFS序(时间戳),同时记录每个节点所在链的顶端节点(用于路径查询,但本题只需要子树查询,所以这一步可以简化,但我们还是按标准剖分来做)。 3. 建立线段树:在DFS序上建立线段树,支持单点更新和区间求和。 子树查询:对于节点u,其子树对应的区间为[in[u], out[u]](即DFS进入和退出的时间戳)。注意:在树链剖分中,由于优先遍历重儿子,子树节点在DFS序中仍然是连续的。 因此,我们可以使用线段树来维护这个区间和。 伪代码(Python风格)如下: ```python import sys sys.setrecursionlimit(200000) class SegmentTree: def __init__(self, data): self.n = len(data) self.size = 1 while self.size < self.n: self.size *= 2 self.tree = [0] * (2 * self.size) # 构建线段树,初始数据 for i in range(self.n): self.tree[self.size + i] = data[i] for i in range(self.size - 1, 0, -1): self.tree[i] = self.tree[2*i] + self.tree[2*i+1] def update(self, index, value): # 单点更新:将位置index的值改为value(注意:这里是直接赋值,如果是增加则需要调整) # 但通常我们支持增加一个差值,这里按需求,我们假设是更新为新的值,所以需要知道旧值?或者我们设计为增加一个增量? # 根据问题,节点改变权值,我们可以用增量更新。但为了通用,这里我们实现为单点设置值,但需要知道原值?或者我们设计为传入增量(更符合动态更新)。 # 这里我们实现为增量更新(delta) # index: 原始数组中的位置(0-indexed) pos = index + self.size self.tree[pos] += value # 增加一个增量 while pos > 1: pos //= 2 self.tree[pos] = self.tree[2*pos] + self.tree[2*pos+1] def query(self, l, r): # 区间查询 [l, r] (闭区间) l += self.size r += self.size res = 0 while l <= r: if l % 2 == 1: res += self.tree[l] l += 1 if r % 2 == 0: res += self.tree[r] r -= 1 l //= 2 r //= 2 return res # 树链剖分部分 n = 100000 graph = [[] for _ in range(n+1)] # 第一次DFS:计算父节点、深度、子树大小、重儿子 parent = [0] * (n+1) depth = [0] * (n+1) size = [0] * (n+1) heavy = [-1] * (n+1) # 重儿子,初始化为-1 def dfs1(u, p, d): parent[u] = p depth[u] = d size[u] = 1 max_size = 0 for v in graph[u]: if v == p: continue dfs1(v, u, d+1) size[u] += size[v] if size[v] > max_size: max_size = size[v] heavy[u] = v # 第二次DFS:确定DFS序(时间戳)和重链的顶端 head = [0] * (n+1) # 链的顶端节点 pos = [-1] * (n+1) # 节点在DFS序中的位置(时间戳) cur_time = 0 def dfs2(u, h): global cur_time head[u] = h pos[u] = cur_time cur_time += 1 # 如果有重儿子,先遍历重儿子 if heavy[u] != -1: dfs2(heavy[u], h) for v in graph[u]: if v == parent[u] or v == heavy[u]: continue dfs2(v, v) # 轻儿子,自己作为新链的顶端 # 初始化 def init_tree(root): dfs1(root, 0, 0) dfs2(root, root) # 初始化一个长度为n(节点数)的数组,初始权值,假设为0,或者根据实际输入 arr = [0] * n # 注意:节点从1开始,时间戳从0到n-1 seg_tree = SegmentTree(arr) return seg_tree, pos, head # 返回线段树和位置数组 # 更新节点u的权值(增加delta) def update_node(seg_tree, u, delta): idx = pos[u] # 节点u在线段树中的位置 seg_tree.update(idx, delta) # 查询子树u的权值和:子树u对应的区间为 [pos[u], pos[u]+size[u]-1] ?注意:在树链剖分的DFS序中,子树u的节点在区间[pos[u], pos[u]+size[u]-1]内吗? # 实际上,在第二次DFS中,我们优先遍历重儿子,然后轻儿子。子树u的DFS序区间是连续的,因为递归完子树后才会遍历下一个子树。所以子树u的区间为 [pos[u], pos[u] + size[u] - 1]。 def query_subtree(seg_tree, u): l = pos[u] r = pos[u] + size[u] - 1 return seg_tree.query(l, r) # 注意:这里线段树的区间是[0, n-1],所以直接使用pos[u]和pos[u]+size[u]-1即可。 ``` ### 注意点: - 树链剖分的DFS序保证了每个子树是连续的,所以我们可以用区间[pos[u], pos[u]+size[u]-1]表示子树。 - 线段树支持区间求和和单点更新(增量更新)。如果节点权值改变为新的值,则需要计算增量(新值-旧值)然后更新。 ### 时间复杂度: - 预处理:两次DFS,O(n) - 更新:O(log n) - 查询:O(log n) ### 与树状数组+DFS序的对比: - 树状数组+DFS序(普通DFS序)同样可以做到,且树状数组常数更小,代码更简单。 - 树链剖分的主要优势在于可以同时支持路径查询(而不仅仅是子树查询)。如果问题需要查询路径上的权值和,树链剖分就更有优势。 ### 总结: 对于子树查询,树状数组+普通DFS序已经足够高效。树链剖分+线段树也可以实现,但代码稍复杂,但扩展性强(支持路径查询)。本题要求子树查询,两种方法均可,但树链剖分在这里有点“大材小用”。 §§相关问题§§ 1. 树链剖分中重链和轻链的作用是什么?为什么优先遍历重儿子? 2. 除了子树查询,树链剖分还能支持哪些类型的查询和操作? 3. 如果树的结构是动态变化的(如添加或删除边),如何维护树链剖分? 4. 线段树和树状数组在实现子树查询时各自的优缺点是什么?</think>对于树结构不变、节点数不超过 100,000 的场景,使用 **线段树 + 树链剖分** 是高效支持子树权值查询和节点权值更新的解决方案。树链剖分将树结构转化为线性序列,线段树则提供高效的区间查询和单点更新能力。 ### 解决方案步骤: 1. **树链剖分预处理**: - **第一次 DFS**:计算每个节点的父节点、深度、子树大小(`size[u]`)和重儿子(子树最大的子节点) - **第二次 DFS**:生成 DFS 序(优先遍历重儿子),记录节点入序时间戳 `dfn[u]` 和子树结束时间 `end[u]`(子树节点在 DFS 序中连续) 2. **线段树构建**: - 基于 DFS 序构建线段树,叶子节点存储原始节点权值 - 支持单点更新(节点权值修改)和区间查询(子树权值和) ### 代码实现(Python 风格) ```python import sys sys.setrecursionlimit(200000) class SegmentTree: def __init__(self, n): self.n = n self.size = 1 while self.size < n: self.size *= 2 self.tree = [0] * (2 * self.size) def update(self, index, delta): """单点更新:位置 index 增加 delta""" i = index + self.size self.tree[i] += delta while i > 1: i //= 2 self.tree[i] = self.tree[2*i] + self.tree[2*i+1] def query(self, l, r): """区间查询 [l, r] 的和""" l += self.size r += self.size res = 0 while l <= r: if l % 2 == 1: res += self.tree[l] l += 1 if r % 2 == 0: res += self.tree[r] r -= 1 l //= 2 r //= 2 return res # 树链剖分预处理 n = 100000 # 最大节点数 graph = [[] for _ in range(n+1)] parent = [0] * (n+1) # 父节点 depth = [0] * (n+1) # 深度 size = [0] * (n+1) # 子树大小 heavy = [-1] * (n+1) # 重儿子 dfn = [0] * (n+1) # DFS 入序时间戳 end = [0] * (n+1) # 子树结束时间戳 cur_time = 0 def dfs1(u, p, d): """第一次 DFS:计算 size/heavy""" parent[u] = p depth[u] = d size[u] = 1 max_size = 0 for v in graph[u]: if v == p: continue dfs1(v, u, d+1) size[u] += size[v] if size[v] > max_size: max_size = size[v] heavy[u] = v def dfs2(u, head): """第二次 DFS:生成 DFS 序""" global cur_time dfn[u] = cur_time cur_time += 1 # 优先遍历重儿子 if heavy[u] != -1: dfs2(heavy[u], head) # 重儿子继承当前链头 for v in graph[u]: if v == parent[u] or v == heavy[u]: continue dfs2(v, v) # 轻儿子作为新链头 end[u] = cur_time - 1 # 子树结束时间 # 初始化树链剖分 def init_tree(root=1): dfs1(root, 0, 0) dfs2(root, root) # 根节点作为第一条链的链头 return SegmentTree(cur_time) # 创建线段树 # 更新节点 u 的权值 (新值 new_val) def update_node(seg_tree, u, new_val, old_val): delta = new_val - old_val seg_tree.update(dfn[u], delta) # 查询子树 u 的权值和 def query_subtree(seg_tree, u): return seg_tree.query(dfn[u], end[u]) # 使用示例 if __name__ == "__main__": # 假设树已构建在 graph 中,root=1 seg_tree = init_tree() # 初始化节点权值 (假设存储在 node_val 数组) for u in range(1, n+1): seg_tree.update(dfn[u], node_val[u]) # 示例:更新节点 5 权值为 10 (旧值假设为 7) update_node(seg_tree, 5, 10, 7) # 示例:查询子树 3 的权值和 print(query_subtree(seg_tree, 3)) ``` ### 时间复杂度分析 | 操作 | 时间复杂度 | 说明 | |--------------|------------|--------------------------| | 树链剖分预处理 | O(n) | 两次 DFS 遍历 | | 单点权值更新 | O(log n) | 线段树单点更新 | | 子树权值查询 | O(log n) | 线段树区间查询 | ### 优势与适用场景 1. **树链剖分优势**: - 将子树查询转化为 **连续区间查询**(`[dfn[u], end[u]]`) - DFS 序连续性由重链优先遍历保证 2. **线段树优势**: - O(log n) 高效区间求和 - 支持动态点更新 3. **扩展性**: - 可扩展支持路径查询(通过跳链查询) - 可支持其他聚合操作(最大值、最小值等) 此方案在节点数 100,000 时完全可行,预处理 O(n),每次操作 O(log n)。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值