ZOJ 3765 —— Lights(伸展树)

本文通过ZOJ的一道题目详细介绍了伸展树(Splay Tree)的应用。文章分享了一个使用伸展树解决最大公约数问题的代码实现,并针对该问题进行了讨论。通过实战案例,读者可以了解伸展树的数据结构特点及其在实际编程竞赛中的应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3765

昨天比赛的时候,别人都把这题KO我却只能干瞪眼,虽然感觉是伸展树,可是之前一直没真正去学这东西。

事后学了下这个东西马上回去ZOJ把这题QJ了!

伸展树(Splay Tree)这东西太神奇啦!

我是看cxlove大牛的文章学习的:http://blog.youkuaiyun.com/acm_cxlove/article/details/7815019


关于ZOJ这题,呃,题目有点繁琐,但其实还是很裸的Splay,只是记录最大公约数的时候要分成01两个状态来记录。

PS:感觉部分自己写的代码还是有点乱。。。

#include<cstdio>
#include<cstring>
#define maxn 300010
#define Key_value ch[ch[root][1]][0]
int gcd(int x, int y){
    if(x<y){
        x^=y; y^=x; x^=y;
    }
    if(y<=0)  return x;
    int z=x%y;
    while(z){
        x=y; y=z; z=x%y;
    }
    return y;
}
int n, q, a[maxn], b[maxn];
int root, tot, ch[maxn][2];
int size[maxn], key[maxn], pre[maxn], g[maxn][2], st[maxn];
void Push_Up(int r){
    int left = ch[r][0];
    int right = ch[r][1];
    size[r] = size[left]+size[right]+1;
    g[r][0] = gcd(g[left][0], g[right][0]);
    g[r][1] = gcd(g[left][1], g[right][1]);
    g[r][st[r]] = gcd(g[r][st[r]], key[r]);
}
void NewNode(int& r,int k,int s,int father){
    r=++tot;
    key[r]=k;
    pre[r]=father;
    st[r]=s;
    ch[r][0]=ch[r][1]=0;
}
void Build(int& r,int L,int R,int father){
    if(L>R) return;
    int mid=(L+R)>>1;
    NewNode(r,a[mid],b[mid],father);
    Build(ch[r][0],L,mid-1,r);
    Build(ch[r][1],mid+1,R,r);
    Push_Up(r);
}
void init(){
    root=tot=0;
    ch[root][0]=ch[root][1]=pre[root]=size[root]=st[root]=0;
    g[root][0]=g[root][1]=-1;
    NewNode(root,-1,0,0);
    NewNode(ch[root][1],-1,0,root);
    size[root]=2;
    for(int i=1; i<=n; i++){
        scanf("%d %d", a+i, b+i);
    }
    Build(Key_value, 1, n, ch[root][1]);
    Push_Up(ch[root][1]);
    Push_Up(root);
}
int Get_Kth(int r, int k){
    int t=size[ch[r][0]];
    if(t==k-1)  return r;
    if(t>=k)    return Get_Kth(ch[r][0],k);
    else    return Get_Kth(ch[r][1],k-t-1);
}
int Get_Min(int r){
    while(ch[r][0]){
        r=ch[r][0];
    }
    return r;
}
void Rotate(int r, int kind){
    int y = pre[r];
    ch[y][!kind] = ch[r][kind];
    pre[ch[r][kind]]=y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=r;
    pre[r]=pre[y];
    ch[r][kind]=y;
    pre[y]=r;
    Push_Up(y);
}
void Splay(int r, int goal){
    while(pre[r]!=goal){
        if(pre[pre[r]]==goal){
            Rotate(r, ch[pre[r]][0]==r);
        }
        else{
            int y=pre[r];
            int kind = (ch[pre[y]][0]==y);
            if(ch[y][kind]==r){
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else{
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    Push_Up(r);
    if(!goal)   root=r;
}
void Query(int a, int b, int c){
    int x = Get_Kth(root, a);
    int y = Get_Kth(root, b+2);
    Splay(x, 0);
    Splay(y, root);
    printf("%d\n", g[Key_value][c]);
}
void Insert(int a, int b, int c){
    int x = Get_Kth(root,a+1);
    Splay(x, 0);
    int y = Get_Min(ch[root][1]);
    Splay(y, root);
    int left=x, right=y;
    NewNode(root,b,c,0);
    ch[root][0]=left;
    ch[root][1]=right;
    ch[left][1]=0;
    pre[left]=root;
    pre[right]=root;
    Push_Up(left);
    Push_Up(root);
}
void Del(int a){
    int x = Get_Kth(root, a+1);
    Splay(x, 0);
    int y = Get_Min(ch[root][1]);
    Splay(y, root);
    pre[ch[x][0]] = y;
    ch[y][0] = ch[x][0];
    pre[y]=0;
    root=y;
    Push_Up(y);
}
void Turn(int a){
    int x = Get_Kth(root, a+1);
    Splay(x, 0);
    st[x]^=1;
    Push_Up(x);
}
void Change(int a, int b){
    int x = Get_Kth(root, a+1);
    Splay(x, 0);
    key[x]=b;
    Push_Up(x);
}
inline void IN(int& x){
    x=0;
    char ch=getchar();
    while(ch<48 || ch>57)   ch=getchar();
    while(ch>=48 && ch<=57){
        x=x*10+ch-48;
        ch=getchar();
    }
}
int main(){
    while(~scanf("%d %d", &n, &q)){
        init();
        char op[10];
        int x, y, z;
        while(q--){
            scanf("%s", op);
            if(op[0]=='Q'){
                IN(x); IN(y); IN(z);
                Query(x,y,z);
            }
            else if(op[0]=='I'){
                IN(x); IN(y); IN(z);
                Insert(x,y,z);
            }
            else if(op[0]=='D'){
                IN(x);
                Del(x);
            }
            else if(op[0]=='R'){
                IN(x);
                Turn(x);
            }
            else{
                IN(x); IN(y);
                Change(x,y);
            }
        }
    }
    return 0;
}


### ZOJ 1088 线段树 解题思路 #### 题目概述 ZOJ 1088 是一道涉及动态维护区间的经典问题。通常情况下,这类问题可以通过线段树来高效解决。题目可能涉及到对数组的区间修改以及单点查询或者区间查询。 --- #### 线段树的核心概念 线段树是一种基于分治思想的数据结构,能够快速处理区间上的各种操作,比如求和、最大值/最小值等。其基本原理如下: - **构建阶段**:通过递归方式将原数组划分为多个小区间,并存储在二叉树形式的节点中。 - **更新阶段**:当某一段区间被修改时,仅需沿着对应路径向下更新部分节点即可完成全局调整。 - **查询阶段**:利用懒惰标记(Lazy Propagation),可以在 $O(\log n)$ 时间复杂度内完成任意范围内的计算。 具体到本题,假设我们需要支持以下两种主要功能: 1. 对指定区间 `[L, R]` 执行某种操作(如增加固定数值 `val`); 2. 查询某一位置或特定区间的属性(如总和或其他统计量)。 以下是针对此场景设计的一种通用实现方案: --- #### 实现代码 (Python) ```python class SegmentTree: def __init__(self, size): self.size = size self.tree_sum = [0] * (4 * size) # 存储区间和 self.lazy_add = [0] * (4 * size) # 延迟更新标志 def push_up(self, node): """ 更新父节点 """ self.tree_sum[node] = self.tree_sum[2*node+1] + self.tree_sum[2*node+2] def build_tree(self, node, start, end, array): """ 构建线段树 """ if start == end: # 到达叶节点 self.tree_sum[node] = array[start] return mid = (start + end) // 2 self.build_tree(2*node+1, start, mid, array) self.build_tree(2*node+2, mid+1, end, array) self.push_up(node) def update_range(self, node, start, end, l, r, val): """ 区间更新 [l,r], 加上 val """ if l <= start and end <= r: # 当前区间完全覆盖目标区间 self.tree_sum[node] += (end - start + 1) * val self.lazy_add[node] += val return mid = (start + end) // 2 if self.lazy_add[node]: # 下传延迟标记 self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: self.update_range(2*node+1, start, mid, l, r, val) if r > mid: self.update_range(2*node+2, mid+1, end, l, r, val) self.push_up(node) def query_sum(self, node, start, end, l, r): """ 查询区间[l,r]的和 """ if l <= start and end <= r: # 完全匹配 return self.tree_sum[node] mid = (start + end) // 2 res = 0 if self.lazy_add[node]: self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: res += self.query_sum(2*node+1, start, mid, l, r) if r > mid: res += self.query_sum(2*node+2, mid+1, end, l, r) return res def solve(): import sys input = sys.stdin.read data = input().split() N, Q = int(data[0]), int(data[1]) # 数组大小 和 操作数量 A = list(map(int, data[2:N+2])) # 初始化数组 st = SegmentTree(N) st.build_tree(0, 0, N-1, A) idx = N + 2 results = [] for _ in range(Q): op_type = data[idx]; idx += 1 L, R = map(int, data[idx:idx+2]); idx += 2 if op_type == 'Q': # 查询[L,R]的和 result = st.query_sum(0, 0, N-1, L-1, R-1) results.append(result) elif op_type == 'U': # 修改[L,R]+X X = int(data[idx]); idx += 1 st.update_range(0, 0, N-1, L-1, R-1, X) print("\n".join(map(str, results))) solve() ``` --- #### 关键点解析 1. **初始化与构建**:在线段树创建过程中,需要遍历输入数据并将其映射至对应的叶子节点[^1]。 2. **延迟传播机制**:为了优化性能,在执行批量更新时不立即作用于所有受影响区域,而是记录更改意图并通过后续访问逐步生效[^2]。 3. **时间复杂度分析**:由于每层最多只访问两个子树分支,因此无论是更新还是查询都维持在 $O(\log n)$ 范围内[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值