hiho_1079_离散化

题目

在长度为L的宣传栏上张贴N张海报，将宣传栏分为L个长度为1的单位，海报长度为整数，且高度和宣传栏相同，左右边界和宣传栏单位之间缝隙重合（即海报总是跨越整数个单位）。后贴的海报可能会覆盖之前贴的海报的全部或者部分，问N张海报贴完之后，没有被完全覆盖的海报的总数。N <= 10^6, L <= 10^9.

分析

区间覆盖问题，会想到用线段树来解决，直观的将L个单位视为线段树的叶子节点，但是这样做空间复杂度太高（同样时间复杂度也很高），可以将区间进行离散化： 
    将所有海报的边界先收集起来，按照从小到大排序后去重，这样得到的离散点映射到从0开始，每次增加1的一个区间上，然后将该区间映射到线段树上。 
    线段树的节点结构中维护两个信息：（1）该节点代表的区间是否只有一个海报single_post，（2）如果只有一个海报，则记录海报序号post。 
    插入海报的时候，找到海报的左右边界点对应到线段树的叶节点编号构成的区间A，然后从根节点开始递归，如果到达某个节点，该节点代表区间B和A相同，则设置该节点的single_post为true，且post为海报号，否则向下找； 
    最后查询的时候，从线段树根节点开始向下找，找到所有的区间内只有一个海报的节点，并将海报号记录下来。

实现

#include<iostream>
#include<string.h>
#include<iostream>
#include<queue>
#include<cmath>
#include<unordered_map>
#include<unordered_set>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
const int inf = 1 << 29;
const int kMax = 200005;
unordered_map<int, int> discrete_map; //海报所贴的端点到线段树区间端点的映射
int gPost[kMax >> 1][2]; //海报的左右边界
vector<int> gPoints;	//存放海报的端点
unordered_set<int> uncovered_post; //没有被遮盖的海报序号
struct Node{
	int beg;
	int end;
	int post;
	bool single_post;
	Node(){
		beg = end = 0;
		single_post = true;
		post = -1;
	}
};
Node gNodes[kMax << 2];

//连续型的区间 线段树
void BuildTree(int node, int beg, int end){
	gNodes[node].beg = beg;
	gNodes[node].end = end;
	if (beg + 1 == end){
		//连续型的区间，线段树的叶子节点表示一个单位长度[i, i+1]，而不是一个点[i, i].
		return;
	}
	int mid = (beg + end) >> 1;
	int left = 2 * node + 1, right = 2 * node + 2;
	BuildTree(left, beg, mid);
	BuildTree(right, mid, end);
	//连续型的区间，[beg, mid] & [mid, end]; 而离散型的区间[beg, mid]&[mid + 1, end]
}

void PushDown(int node){
	if (gNodes[node].beg + 1 == gNodes[node].end)
		return;
	if (gNodes[node].single_post){
		int left = 2 * node + 1, right = 2 * node + 2;
		gNodes[left].post = gNodes[right].post = gNodes[node].post;
		gNodes[left].single_post = gNodes[right].single_post = true;
		gNodes[node].single_post = false;
	}
}

void Post(int node, int beg, int end, int post){
	if (gNodes[node].beg == beg && gNodes[node].end == end){
		gNodes[node].single_post = true;
		gNodes[node].post = post;
		return;
	}
	PushDown(node);
	int left = 2 * node + 1, right = 2 * node + 2;
	int mid = (gNodes[node].beg + gNodes[node].end) / 2;
	if (beg >= mid){
		Post(right, beg, end, post);
	}
	else if (end <= mid){
		Post(left, beg, end, post);
	}
	else{
		Post(left, beg, mid, post);
		Post(right, mid, end, post);
	}
}
void Query(int node){
	if (gNodes[node].single_post && gNodes[node].post != -1){
		uncovered_post.insert(gNodes[node].post);
		return;
	}
	if (gNodes[node].beg + 1 == gNodes[node].end){
		return;
	}
	int left = 2 * node + 1, right = 2 * node + 2;
	Query(left);
	Query(right);
}

int main(){
	int N, L;
	scanf("%d %d", &N, &L);
	for (int i = 0; i < N; i++){
		scanf("%d %d", &gPost[i][0], &gPost[i][1]);
		//将各个离散点加入vector
		gPoints.push_back(gPost[i][0]);
		gPoints.push_back(gPost[i][1]);
	}

	//先排序
	sort(gPoints.begin(), gPoints.end());

	//对vector去重
	gPoints.resize(std::distance(gPoints.begin(), unique(gPoints.begin(), gPoints.end())));

	BuildTree(0, 0, gPoints.size() - 1);
	//将离散化的点，按照大小映射到一个连续的区间，缩小数据规模
	for (int i = 0; i < gPoints.size(); i++){
		discrete_map[gPoints[i]] = i;
	}
	for (int i = 0; i < N; i++){
		Post(0, discrete_map[gPost[i][0]], discrete_map[gPost[i][1]], i);
	}
	Query(0);
	int result = uncovered_post.size();
	printf("%d\n", result);
	return 0;
}