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;
}