zoj 2112 (主席树)

Orz......

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 60010;
const int MAXQ = 10010;
const int MAXM = 2500010;

int n, m, dex;
int a[MAXN], sorted[MAXN], root[MAXN], lower[MAXN], temp[MAXN];
int T[MAXM], lson[MAXM], rson[MAXM];

struct Query {
	int kind, a, b, c;
}query[MAXQ];

int BuildT(int l, int r) {
	int now = ++dex;
	T[now] = 0;
	if(l == r) return now;
	int mid = (l + r) >> 1;
	lson[now] = BuildT(l, mid);
	rson[now] = BuildT(mid + 1, r);
	return now;
}

int UpdateT(int oldroot, int pos, int val) {
	int now = ++dex;
	int tmp = now;
	T[now] = T[oldroot] + val;
	int l = 1, r = m;
	while(l < r) {
		int mid = (l + r) >> 1;
		if(pos <= mid) {
			rson[now] = rson[oldroot];
			lson[now] = ++dex;
			T[lson[now]] = T[lson[oldroot]] + val;
			now = lson[now], oldroot = lson[oldroot];
			r = mid;
		}
		else {
			lson[now] = lson[oldroot];
			rson[now] = ++dex;
			T[rson[now]] = T[rson[oldroot]] + val;
			now = rson[now], oldroot = rson[oldroot];
			l = mid + 1;
		}
	}
	T[now] = T[oldroot] + val;
	return tmp;
}

int lowerbit(int x) {
	return x & (-x);
}

int getsum(int x) {
	int ans = 0;
	while(x) {
		ans += T[lson[temp[x]]];
		x -= lowerbit(x);
	}
	return ans;
}

int QueryT(int l, int r, int k) {
	int rootl = root[l];
	int rootr = root[r];
	int left = 1, right = m;
	for(int i = r; i; i -= lowerbit(i)) temp[i] = lower[i];
	for(int i = l; i; i -= lowerbit(i)) temp[i] = lower[i];
	while(left < right) {
		int con = T[lson[rootr]] - T[lson[rootl]] + getsum(r) - getsum(l);
		int mid = (left + right) >> 1;
		if(k <= con) {
			for(int i = r; i; i -= lowerbit(i)) temp[i] = lson[temp[i]];
			for(int i = l; i; i -= lowerbit(i)) temp[i] = lson[temp[i]];
			rootl = lson[rootl], rootr = lson[rootr];
			right = mid;
		}
		else {
			k -= con;	
			for(int i = r; i; i -= lowerbit(i)) temp[i] = rson[temp[i]];
			for(int i = l; i; i -= lowerbit(i)) temp[i] = rson[temp[i]];
			rootl = rson[rootl], rootr = rson[rootr];
			left = mid + 1;
		}
	}
	return left;
}

void UpdateL(int x, int pos, int val) {
	while(x <= n) {
		lower[x] = UpdateT(lower[x], pos, val);
		x += lowerbit(x);
	}
}

int main() {
	int t;
	scanf("%d", &t);
	while(t--) {
		int q;
		dex = m = 0;
		scanf("%d%d", &n, &q);
		for(int i = 1; i <= n; i++) scanf("%d", &a[i]), sorted[++m] = a[i];
		char op[2];	
		for(int i = 1; i <= q; i++) {
			scanf("%s", op);
			if(op[0] == 'Q') scanf("%d%d%d", &query[i].a, &query[i].b, &query[i].c), query[i].kind = 1;
			else scanf("%d%d", &query[i].a, &query[i].b), query[i].kind = 2, sorted[++m] = query[i].b;
		}
		sort(sorted + 1, sorted + 1 + m);
		m = unique(sorted + 1, sorted + 1 + m) - sorted - 1;
		root[0] = BuildT(1, m);
		for(int i = 1; i <= n; i++) {
			int pos = lower_bound(sorted + 1, sorted + 1 + m, a[i]) - sorted;
			root[i] = UpdateT(root[i - 1], pos, 1);
		}
		for(int i = 1; i <= n; i++) lower[i] = root[0];
		for(int i = 1; i <= q; i++) {
			if(query[i].kind == 1) printf("%d\n", sorted[QueryT(query[i].a - 1, query[i].b, query[i].c)]);
			else {
				int pos = lower_bound(sorted + 1, sorted + 1 + m, a[query[i].a]) - sorted;
				UpdateL(query[i].a, pos, -1);
				pos = lower_bound(sorted + 1, sorted + 1 + m, query[i].b) - sorted;
				UpdateL(query[i].a, pos, 1);
				a[query[i].a] = query[i].b;
			}
		}
	}
	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、付费专栏及课程。

余额充值