ZOJ_1610_第一次写线段树

本文详细介绍了一种数据结构——线段树的创建过程、着色操作及统计方法,并通过ZJU_1610问题的具体实现进行阐述。

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

//============================================================================
// Name        : ZJU_1610.cpp
// Author      : tiger
/*
 *第一次写线段树 ,终于O了。。。

    1。创建线段树

    1)取最小和最大的两个数作为端点,建立线段树

    2)当前节点的两个端点值之差等于一时,此时该节点即位叶子节点,不用再 向下分

    3)否则,分裂该节点为[a,(a + b) / 2], [(a + b) / 2, b];

    4)创建线段树时,注意初始化操作

    2。线段树着色(根据不同的题目此操作各不相同,对zju_1610做分析)

    1)当前节点的颜色与将要涂的颜色color相同,直接return

    2)当前线段树节点的两个端点和要涂的两个端点正好都相同,则将该节点着为color,然后return

    3)要涂的两个端点在当前节点的两个端点之间时:先将当前节点的颜色向其子节点扩展,然后:

       1.要涂的右端点小于或等于当前节点middle = (a + b) / 2时,向左子节点移动

       2.要涂的左端点大于或等于当前节点middle = (a + b) / 2时,向右子节点移动

       3.else (1 ,2)向左右子节点移动

    3。相关统计

   1)当前节点未着色或其颜色与要统计的颜色不相同,直接return

   2)从0——8000依次扫描,如果还是原来的数,即还是一条颜色,那么 continue,不计,是其他颜色,ans[c]++;
 */
//============================================================================

#include <iostream>
#include <string>
using namespace std;
#define MAX 8000
struct Node
{
    int l,r;
    int c;
};
Node tree[MAX*4];
int ans[MAX+10];
int seg[MAX+10];
void Initial(int i,int l, int r,int c)
{
    if(l>=r )
        return;
    tree[i].l = l;
    tree[i].r = r;
    tree[i].c = c;
    if(r - l == 1)
        return;
    int mid = (tree[i].l+tree[i].r) >> 1;
    Initial(i*2,l,mid,c);
    Initial(i*2+1,mid,r,c);
}
void add(int i,int l,int r,int c)
{
    if(c == tree[i].c)
    {
        return ;
    }
    if(l == tree[i].l && r == tree[i].r)
    {
            tree[i].c = c;

    }else
    {
        int mid = (tree[i].l + tree[i].r) >> 1;
         if(tree[i].c >= 0)
         {
            tree[i*2].c = tree[i].c;
            tree[i*2+1].c = tree[i].c;
         }
          tree[i].c = -1;
        if(l >= mid)
        {
            add(i*2+1,l,r,c);
        }
        else
            if(r <= mid)
            {
                add(i*2,l,r,c);
            }else
            {

                add(i*2,l,mid,c);
                add(i*2+1,mid,r,c);
            }
        if(tree[i*2].c == tree[i*2+1].c)
        {
        tree[i].c = tree[i*2].c;
        }
    }
}
void counts(int i)
{
    if(tree[i].c != -1)
    {
        for(int j = tree[i].l; j <= tree[i].r;j++)
        {
            seg[j] = tree[i].c;
        }
    }
    else
    {
        counts(i*2);
        counts(i*2+1);
    }
}
void total()
{
    int c = seg[0];
    for(int i = 0;i <= MAX;i++)
    {
        if(seg[i]==c)
        continue;
        if(c >= 0) ans[c] ++;
        c= seg[i];

    }
    if(c >= 0) ans[c] ++;
}
int main() {
    freopen("in","r",stdin);
    int i,n,x,y,c;

    while(scanf("%d",&n) != EOF)
    {
        Initial(1,0,MAX,-2);
        memset(ans,0,sizeof(ans));

        while(n--)
        {
            scanf("%d %d %d",&x,&y,&c);
            add(1,x,y,c);
        }
        counts(1);
        total();
        for(i = 0; i <= MAX; i++)
        {
            if(ans[i])
            {
                printf("%d %d/n",i,ans[i]);
            }
        }
        printf("/n");
    }
    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、付费专栏及课程。

余额充值