2016 UESTC Training for Data Structures B - 卿学姐与基本法 CDOJ 1325 线段树+离散化

 

B题：卿学姐与基本法

题意：给一段区间，长度为1e8，Q次操作（Q<=1e5），

操作有两种，一种是将某个区间进行染色，另一种是查询某个区间未被染色的长度

 

离散化+线段树求区间染色

呃，离散化很简单咯，我的做法就是sort+unique+lower_bound搞定，聊天中柱爷突然说了一句，其实unique可以没有，想了想，真的诶，如果不要求编号必须连续的话，是可以没有unique的，但是习惯有了，所以也无所谓啦

 

然后就是线段树求区间染色，这个因为是相当于01染色的，所以也比较简单，区间更新的时候，就直接修改这个区间的sum，直接把lazy赋值为1，因为下面的子区间肯定也是全被染色的，所以下面子区间的数据就全都没用了，然后查询的时候下放lazy就行。

 

当然这题还有一个问题就是离散化带来的问题，因为离散化后，一个点其实相当于代表一个区间，然后因为我的线段树建的是闭区间的，就是相当于统计的是点，比如[1,4]它的两个子区间就是[1,2]和[3,4]，如果没有离散化自然是没问题的，但是如果离散化的话，比如1,100,200,300，离散化成1,2,3,4，这样的话，我的线段树里[101,199]这段就丢失了，但是这段丢失显然很可能会带来错误，然后我的做法就是每个节点多一个信息tag，表示每个节点的两个子区间中间的这段的信息，然后这个区间的信息最多只会由它的父区间得到，不会由它的子区间得到，所以也是在对应的操作中做对应的修改就行，然后就可以了

 

后来想了想，如果线段树存的是左闭右开区间的话，貌似在每个点前后加点后再离散化，就不会出现上面那个问题，感觉了一下好像是对的，但是没有深入想，，闭区间的写习惯了。。。

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
#define maxq 100005
#define lid (id<<1)
#define rid (id<<1|1)
int N, Q, num;
int data[maxq * 2];
int oper[maxq][3];
struct segtree
{
	int l, r;
	int sum, lazy;
	bool tag;
}tr[maxq * 8];
void discrete()
{
	sort(data + 1, data + 2 * Q + 1);
	num = unique(data + 1, data + 2 * Q + 1) - data;
	/*int t = num;
	for (int i = 2; i < t; ++i)
	{
		if (data[i] - data[i - 1] == 2)
			data[num++] = data[i] - 1;
		else if (data[i] - data[i - 1] >= 2)
		{
			data[num++] = data[i - 1] + 1;
			data[num++] = data[i] - 1;
		}
	}
	sort(data + 1, data + num);*/
	for (int i = 1; i <= Q; ++i)
	{
		oper[i][0] = lower_bound(data, data + num, oper[i][0]) - data;
		oper[i][1] = lower_bound(data, data + num, oper[i][1]) - data;
	}
}
void bulid(int id, int l, int r)
{
	tr[id].l = l; tr[id].r = r;
	if (l == r)
		return;
	int mid = (l + r) >> 1;
	bulid(lid, l, mid);
	bulid(rid, mid + 1, r);
}
void push_down(int id)
{
	if (tr[id].lazy != 0)
	{
		if (tr[id].l < tr[id].r)
		{
			tr[id].tag = 1;
			tr[lid].sum = (data[tr[lid].r] - data[tr[lid].l] + 1)*tr[id].lazy;
			tr[lid].lazy = tr[id].lazy;
			tr[rid].sum = (data[tr[rid].r] - data[tr[rid].l] + 1)*tr[id].lazy;
			tr[rid].lazy = tr[id].lazy;
		}
		tr[id].lazy = 0;
	}
}
void update(int id, int l, int r, int v)
{
	if (l == tr[id].l&&tr[id].r == r)
	{
		tr[id].sum = (data[tr[id].r] - data[tr[id].l] + 1)*v;
		tr[id].lazy = v;
		return;
	}
	push_down(id);
	int mid = (tr[id].l + tr[id].r) >> 1;
	if (r <= mid) update(lid, l, r, v);
	else if (l > mid) update(rid, l, r, v);
	else
	{
		tr[id].tag = 1;
		update(lid, l, mid, v);
		update(rid, mid + 1, r, v);
	}
	tr[id].sum = tr[lid].sum + tr[rid].sum + tr[id].tag*(data[tr[rid].l] - data[tr[lid].r] - 1);
}
int query(int id, int l, int r)
{
	if (l == tr[id].l&&r == tr[id].r)
	{
		return tr[id].sum;
	}
	push_down(id);
	int mid = (tr[id].l + tr[id].r) >> 1;
	if (r <= mid) return query(lid, l, r);
	else if (l > mid) return query(rid, l, r);
	else
	{
		return query(lid, l, mid) + query(rid, mid + 1, r) + tr[id].tag*(data[tr[rid].l] - data[tr[lid].r] - 1);
	}
}
int main()
{
	scanf("%d%d", &N, &Q);
	int a, b, c;
	for (int i = 1; i <= Q; ++i)
	{
		scanf("%d%d%d", &a, &b, &c);
		oper[i][0] = data[2 * i - 1] = b;
		oper[i][1] = data[2 * i] = c;
		oper[i][2] = a;
	}
	discrete();
	bulid(1, 1, num - 1);
	for (int i = 1; i <= Q; ++i)
	{
		if (oper[i][2] == 1)
			update(1, oper[i][0], oper[i][1], 1);
		else if (oper[i][2] == 2)
		{
			printf("%d\n", data[oper[i][1]] - data[oper[i][0]] + 1 - query(1, oper[i][0], oper[i][1]));
		}
	}
	return 0;
}