线段树之离散化（POJ-2528）

线段树之离散化（POJ-2528）

我们知道，在实际应用中使用线段树的时候结点 Node 数组 tree 一般都要开 4 倍的空间大小（4*maxn），但是对于一些情况下 maxn 可能特别大，但是实际上用到的点却很少，如果强行开 4 倍空间的话很可能直接爆栈。

因此我们需要使用到离散化，离散化的使用不仅仅局限于线段树中，还可以应用于其他的场景中，不过在这里只讨论线段树+离散化。

那么什么是离散化呢？ 离散化即把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

假设我们需要在 [1, 10¹⁰] 范围中选取 1000 个点进行操作，那么肯定是没有办法 build(1, 1, 10¹⁰) 的，故我们创建一种映射关系，若我们取了 5 2000 300 1e4 2e5 …

用数组 arr 来保存，arr[] = {5, 2000, 300, 1e4, 2e5 … };

一般离散化都要三个步骤：1. sort 排序 2. unique 去重 3. lower-bound 二分查找

对 arr 进行 sort 以及 unique 后， arr[] = {5, 300, 2000, 1e4, 2e5 … };

处理过后数组的长度为 len，映射关系为：

1——5， 2——300， 3——2000， 4——1e4， 5——2e5 …

这样我们只要 build(1, 1, len) ，创建大小为 4*len 的线段树就可以了。

这样要对区间 [x, y] 进行操作的时候，使用lower-bound 在arr 中找到 x 和 y 对应的索引（离散化后），之后就是一般的线段树做法了。比如区间 [300, 2000] 对应离散化后的 [2, 3]。

使用离散化不仅大大减少了算法的空间复杂度，并且因为减少了结点而提高了时间复杂度。

下面给出了线段树离散化的简单应用题：

POJ-2528 Mayor’s posters

题目大意：在长度为 1e7 的数轴上用不超过 10000 条的不同线段进行覆盖，求最后数轴上可见的不同线段条数。

input：第一行为 case 数量 T，第二行为线段的条数 n (1 <= n <= 10000)，接下来的 n 行每行代表一条线段，其中每行都包含了两个数字，分别为线段的左右端点。

output：对于每个 case 输出最后数轴上可见的不同线段条数。

Sample Input：

1
5
1 4
2 6
8 10
3 4
7 10

Sample Output：

4

思路： 明显的离散化应用，大数据范围小数据点，直接开 1e7 的线段树应该爆掉了。首先得到所有线段的左右端点，对所有端点进行排序去重，这样就得到了离散化后的端点数组。之后再遍历每条线段，使用 lower-bound 找到左右端点对应的离散索引，进行区间修改 change_interval，最后调用一次区间查询 ask_interval 即可。

注意结点 color 要初始化为 -1，这样才不会跟 0 发生冲突。还要注意在 ask_interval 的时候要对扫描过的线段使用 vis 数组进行记录，保证同一条线段不出现多次计数。

参考代码：

// 离散化
#include<cmath>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;

const int maxn = 10000+5;
int n, ans, cnt;

struct Node {
	int left, right;
	int color;
	int f;
} tree[8*maxn]; // 最多会有2e4个叶子节点

int vis[8*maxn];
int li[2*maxn],ri[2*maxn],points[2*maxn];

void build(int k, int l, int r){
	tree[k].left = l;
	tree[k].right = r;
	tree[k].color = -1;
	tree[k].f = -1;
	if(l == r){
		return;
	}
	int mid = (l+r)/2;
	build(2*k, l, mid);
	build(2*k+1, mid+1, r);
}

void down(int k) {
	if(tree[k].left == tree[k].right) return;
	tree[2*k].color = tree[k].color;
	tree[2*k+1].color = tree[k].color;
	tree[k].f = -1;
}

void pushUp(int k){
	if(tree[k].left == tree[k].right) return;
	if(tree[2*k].color == tree[2*k+1].color){
		tree[k].color = tree[2*k].color;
	}
	else{
		tree[k].color = -1;
	}
}

void change_interval(int k, int C, int l, int r) {
	if(tree[k].left >= l && tree[k].right <= r) {
		tree[k].color = tree[k].f = C;
		return ;
	}
	if(tree[k].color != -1) down(k);
	int mid = (tree[k].left+tree[k].right)/2;
	if(mid >= l) change_interval(2*k, C, l, r);
	if(mid < r) change_interval(2*k+1, C, l, r);
	pushUp(k);
}

void ask_interval(int k, int l, int r) {
	if(!vis[tree[k].color] && tree[k].color != -1) {
		ans++;
		vis[tree[k].color] = 1;
		return;
	}
	if(tree[k].left == tree[k].right) return;
	if(tree[k].color!=-1) down(k);
	ask_interval(2*k, l, r);
	ask_interval(2*k+1, l,r);
}

int main() {
	int T;
	scanf("%d", &T);
	while(T--) {
		scanf("%d", &n);
		memset(vis, 0, sizeof(vis));
		int total = 0;
		for(int i = 0; i < n; i++) {
			scanf("%d%d", &li[i], &ri[i]);
			points[total++] = li[i];
			points[total++] = ri[i];
		}
		sort(points, points+total);
		int newn = unique(points, points+total) - points;
		cnt = 0;
		build(1, 0, newn-1);
		for(int i = 0; i < n; i++) {
			int x = lower_bound(points, points+newn, li[i]) - points;
			int y = lower_bound(points, points+newn, ri[i]) - points;
			change_interval(1, i, x, y);
		}
		ans = 0;
		ask_interval(1, 0, newn-1);
		printf("%d\n", ans);
	}
}

【END】感谢观看！