校门外的树（经典题）---区间和并or线段树 over watch---离散化+前缀和

任意门
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。

我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。

由于马路上有一些区域要用来建地铁。

这些区域用它们在数轴上的起始点和终止点表示。

已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。

现在要把这些区域中的树（包括区域端点处的两棵树）移走。

你的任务是计算将这些树都移走后，马路上还有多少棵树。

输入格式

输入文件的第一行有两个整数L和M，L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。

接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。

输出格式

输出文件包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。

数据范围

1≤L≤10000 1≤L≤10000,
1≤M≤100 1≤M≤100

这是一道很经典的题目，就是给一段区间，然后把这一段区间里的树全部移开，问有多少棵留下来。
这个题目有很多种解法，首先说一下比较朴素的写法就是我们每一次询问，都遍历一遍，把这之间的数标1，然后最后记录有多少个1.

区间合并

当然这个方法很傻，我们可以使用一种简单的区间和并

区间合并算法，就是将所有的区间按照左端点，从小到大排序，（有点像那个贪心里面用的方法）从左到右遍历每一个区间，①如果区间有交集，就求并集，用更新左右端点的方法来求并集。②如果没有交集，就把上一个区间给存下来

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string.h>
#include<cstdio>
#include<queue>
#include<cmath>
 
using namespace std;
 
const int N=110;
int m,n;
struct segment//用结构体来存区间
{
    int l,r;
    bool operator<(const segment& t)const
    {
        return l<t.l;
    }//这个就是要自己定义一个结构体的比较函数，然后呢，也可以用pair来代替
}seg[N];
 
int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++)
        cin>>seg[i].l>>seg[i].r;
    sort(seg,seg+n);
    int sum=0;
    int L=seg[0].l,R=seg[0].r;
    for(int i=1;i<n;i++)
        if(seg[i].l<=R)
        R=max(R,seg[i].r);
    else
    {
        sum+=R-L+1;
        L=seg[i].l,R=seg[i].r;
            }
            sum +=R-L+1;
            cout<<m+1-sum<<endl;
            return 0;
}

线段树

由于这道题算是很简单的，我们可以来练线段树

#include<bits/stdc++.h>
#define MAXN 100007
using namespace std;
int n,m,x,y;
struct SegTree{
	int l;//左端点
	int r;//右端点
	long long w;//区间和（表示区间内树的总数）
	int lt;//lazytag(懒惰标记)
	int add;
	int mul;
	SegTree() {lt=1;}//将lazytag初始化为一
}tree[MAXN<<2];  //注意tree数组的长度至少为maxn*4
inline void build(int l,int r,int u)//建树
{
	tree[u].l=l,tree[u].r=r;
	if(l==r) {tree[u].w=1;return;}//一旦找到叶节点，直接将值赋为1(因为没个点上只有一棵树)
	int m=(l+r)/2;//二分
	build(l,m,u+u);
	build(m+1,r,u+u+1);
	tree[u].w=tree[u+u].w+tree[u+u+1].w;//区间和即为两子树的区间和之和（绕口但不难理解）
}
inline void down(int u)//下推lazytag
{
	tree[u+u].lt=tree[u].lt;  //直接将lazytag赋给子节点
	tree[u+u+1].lt=tree[u].lt;
	tree[u+u].w=tree[u].lt;   //由于lazytag被标记后值为0，修改区间内的树也要变为0，所以直接将lazytag赋给子节点的w
	tree[u+u+1].w=tree[u].lt;
	tree[u].lt=1;            //将标记去掉
}
inline void change(int u)//区间修改
{
	if(tree[u].l>=x&&tree[u].r<=y) //若该区间被待修改区间覆盖，直接将区间和清0（树要全部去掉），并打上标记
	{
		tree[u].w=0;
		tree[u].lt=0;
		return;
	}
	if(tree[u].lt!=1) down(u);//若有标记则下推
	int m=(tree[u].l+tree[u].r)/2;
	if(x<=m) change(u+u);//判断中点左右是否有待修改的点
	if(y>m) change(u+u+1);
	tree[u].w=tree[u+u+1].w+tree[u+u].w;//更新当前点的区间和
}
int main()
{
	scanf("%d%d",&n,&m); ++n;//树的位置由0~n->1~n+1
	build(1,n,1);
	while(m--)
	{
		scanf("%d%d",&x,&y);
		++x,++y;
		change(1);
	}
	printf("%lld",tree[1].w);//直接输出修改后整个区间之和
	return 0;
}

补充题：

然后今天在补题的时候，就是发现一道题目，就是大概意思就是，告诉你一个区间，让你求这个区间的哪一个节点值最大。

这个题目的数据量呢肯定是不能直接上差分的，所以我们加入离散化。

离散化

什么是离散化呢？

离散化：把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。

离散化常与差分、前缀和、数组数组、线段树结合考查。
基本的步骤可以分为：

1、用一个辅助的数组把你要离散的所有数据存下来。

2、排序，排序是为了后面的二分。

3、去重，因为我们要保证相同的元素离散化后数字相同。

4、索引，再用二分把离散化后的数字放回原数组。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 4e5+10;
int d[N];
int s[N];
vector<pair<int, int>> a;
vector<int> alls;
int n;
int l, r;

int Find(int x)
{
    int l = 0, r = alls.size()-1;
    while(l < r)
    {
        int mid = l + r >> 1;
        if(alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1;
}

void sout(){
    printf("d:");
    for(int i = 1; i <= 5; i++) printf("%4d", d[i]);
    puts("");

    printf("s:");
    for(int i = 1; i <= 5; i++) printf("%4d", s[i]);
    puts("");

    printf("alls:");
    for(int i = 0; i < alls.size(); i++) printf("%4d", alls[i]);
    puts("");
    for(int i = 0; i < alls.size(); i++){
        printf("%4d", Find(alls[i]));
    }
    puts("");

}

signed main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d", &l, &r);
        a.push_back({l, r});
        alls.push_back(l);
        alls.push_back(r);
    }

    // lisanhua
    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), alls.end());

    for(int i = 1; i <= n; i++)
    {
        int l = Find(a[i-1].first);
        int r = Find(a[i-1].second);//利用二分算出该数是第几个
        d[l]++;
        d[r]--;
    }

    for(int i = 1; i <= (int) 2e5+10; i++)
    {
        s[i] = s[i-1] + d[i];//再利用前缀和
    }
    int ans = 0;
    for(int i = 1; i <= 2e5 + 10; i++) ans = max(ans, s[i]);
    printf("%d\n", ans);
    return 0;
}