【ZOJ】1610 Count the Colors(线段树查找隔断的线段)

本文探讨了一个利用线段树解决颜色分割问题的方法,详细解释了如何使用线段树来查找并统计每种颜色的段数,提供了一种暴力但有效的问题求解路径。同时,文章反思了个人在面对复杂变形题时的挑战,强调了实践与经验积累的重要性。

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

题目大意:有一条最长8000的线段,其中会被最多8000种颜色分割,问一整段是全部颜色的算1,这样每种颜色有多少段呢?

这道题目一开始的思路线段树存放的自然是每一段的情况,设定-1,假如不是-1的话,就表示该段颜色都是相同的,是-1的话,表示下面颜色可以继续分。

只是在查找的时候自己犯难了,想不到怎么去将所有颜色的次数查找出来。

看了题解,这边用的想法是这样的,通过线段树的query功能,每次对分query,直到遇到一段线段是纯色的就不再往下,并且将这段加入事先的数组当中。

最后再遍历这些数组,只要这一条线段与下一条线段的颜色不一样,并且不是相连的,那么对应颜色的次数就++。就是这么暴力,直接!!

曾经竞赛不怕变形题的我,现在只能做做模板题,稍微变形就不会,这真的是因为我做题目没有以前花时间的原因吗?无奈,大学太多事了。

AC代码:

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAX 8008
#define ls rt<<1
#define rs ls|1
#define m (l+r)>>1
int sum[MAX << 2];
int a[MAX];
int cnt;
struct pos
{
	int l, r, c;
}p[MAX];
void ups(int rt)
{
	if (sum[rt] != -1)
	{
		sum[ls] = sum[rt];
		sum[rs] = sum[rt];
		sum[rt] = -1;
	}
}

void uprt(int rt)
{
	if (sum[ls] == sum[rs])
		sum[rt] = sum[ls];
}

void updata(int L, int R,int c, int l, int r, int rt)
{
	if (L <= l&&r <= R)
	{
		sum[rt] = c;
		return;
	}
	ups(rt);
	int mid = m;
	if (L < mid)
		updata(L, R, c, l, mid, ls);
	if (mid < R)
		updata(L, R, c, mid, r, rs);
	uprt(rt);
}

void query(int l, int r, int rt)
{
	if (sum[rt] != -1)
	{
		p[cnt].l = l;
		p[cnt].r = r;
		p[cnt++].c = sum[rt];
		return;
	}
	int mid = m;
	if (l == r - 1)return;
	query(l, mid, ls);
	query(mid, r, rs);
}
int main()
{
	int n;
	int L, R,C;
	while (~scanf("%d", &n))
	{
		memset(sum, -1, sizeof(sum));
		memset(a, 0, sizeof(a));
		cnt = 0;
		C = 0;
		int x, y, z;
		for (int i = 0; i < n; i++)
		{
			scanf("%d%d%d", &x, &y, &z);
			updata(x, y, z, 0, MAX, 1);
			C = max(C, z);
		}
		query(0, MAX, 1);
		for (int i = 0; i < cnt; i++)
		{
			if (i != cnt - 1 && p[i].r == p[i + 1].l&&p[i].c == p[i + 1].c)
				continue;
			a[p[i].c]++; 
		}
		for (int i = 0; i <=C;i++)
		if (a[i])
			printf("%d %d\n", i, a[i]);
		cout << endl;
	}
}


### 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、付费专栏及课程。

余额充值