纸带 线段树+离散化

题目大意：每次给一段区间染色，求最后整个区间有多少种颜色；
分析：用膝盖想也知道这题线段树可以轻松水过，于是出题人灵机一动，挖了个深坑，每次给的区间是左开右闭的，但题目没说，他给了你一张图，你们可以感受一下：

于是正解wa成0分我也是很绝望的。有一点要注意一下，离散化后有些区间会并在一起，原来中间的颜色可能会被消掉，于是考虑两次离散化，先离散化一次，若相邻两个点的值不为1，就在中间插一个点，然后再离散化一次。不过仔细对拍后会发现，在1e9内这种情况太少，除非出题人丧心病狂，否则是不会卡的。第二种做法，o（n），每次考虑倒着染色，然后每次用并差集维护，若维护到一段已经属于宁外的集合，就跳到这个集合的最右端继续染。最后盘一下不同集合的个数就ok了，因为n次询问，所以一共合并n-1次，复杂度不超过o（n）。

线段树：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=2e6+5;
struct node
{
    int l,r;
}q[N];
int m,n,ans,b[N<<1];
int tag[N<<3];
bool exist[N];

void lsh()
{
    sort(b+1,b+n+1);
    n=unique(b+1,b+n+1)-b-1;
    int p=n;
    for(int i=2;i<=n;i++)
        if(b[i]!=b[i-1]+1)b[++p]=b[i-1]+1;
    n=p;
    sort(b+1,b+n+1);
    n=unique(b+1,b+n+1)-b-1;
    for(int i=1;i<=m;i++)
    {
        q[i].l=lower_bound(b+1,b+n+1,q[i].l)-b;
        q[i].r=lower_bound(b+1,b+n+1,q[i].r)-b;
    }
}

void pushdown(int k)
{
    tag[k<<1]=tag[k<<1|1]=tag[k];
    tag[k]=0;
}

void modify(int k,int l,int r,int x,int y,int v)
{
    if(x<=l&&r<=y)
    {
        tag[k]=v;
        return;
    }
    if(tag[k])pushdown(k);
    int mid=l+r>>1;
    if(y<=mid)modify(k<<1,l,mid,x,y,v);
    else if(x>mid)modify(k<<1|1,mid+1,r,x,y,v);
    else modify(k<<1,l,mid,x,mid,v),modify(k<<1|1,mid+1,r,mid+1,y,v);
}

void solve(int k,int l,int r)
{
    if(l==r)
    {
        if(tag[k]&&!exist[tag[k]])
            ans++,exist[tag[k]]=1;
        return;
    }
    if(tag[k])pushdown(k);  
    int mid=l+r>>1;
    solve(k<<1,l,mid),solve(k<<1|1,mid+1,r);
}

int main()
{
    //freopen("ribbon.in","r",stdin);
    //freopen("ribbon.out","w",stdout);
    m=getint();
    for(int i=1;i<=m;i++)
    {
        q[i].l=getint()+1,q[i].r=getint();
        b[++n]=q[i].l,b[++n]=q[i].r;
    }
    lsh();
    for(int i=1;i<=m;i++)
        modify(1,1,n,q[i].l,q[i].r,i);
    solve(1,1,n);
    cout<<ans<<'\n';
    return 0;
}

并差集：

#include<iostream>
#include<cstring>
#include<string>
#include<cstdlib>
#include<cstdio>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
#include<algorithm>
#include<queue>
using namespace std;

const int N=4e6+100;
int n,m,tot,cnt,b[N],ans,jump[N],check[N],po,ri[N];
bool flag[N/2];
struct node{
    int l,r;
}a[N/2];

int readint()
{
    char ch;int i=0,f=1;
    for(ch=getchar();(ch<'0'||ch>'9')&&ch!='-';ch=getchar());
    if(ch=='-') {ch=getchar();f=-1;}
    for(;ch>='0'&&ch<='9';ch=getchar()) i=(i<<3)+(i<<1)+ch-'0';
    return i*f;
}

inline int find(int x){
    if(check[x]==0) return x;
    return jump[x]=find(jump[x]);
}

void dis_init()
{
    sort(b+1,b+tot+1);
    //m=unique(b+1,b+tot+1)-b-1;
    int p=m;
    for(int i=2;i<=m;i++)
        if(b[i]!=b[i-1]+1) b[++p]=b[i-1]+1;
    m=p;
    sort(b+1,b+m+1);
    m=unique(b+1,b+tot+1)-b-1;
    for(int i=1;i<=n;i++)
    {
        a[i].l=lower_bound(b+1,b+m+1,a[i].l)-b;
        a[i].r=lower_bound(b+1,b+m+1,a[i].r)-b;
    }
}

int main()
{
    //freopen("ribbon.in","r",stdin);
    //freopen("ribbon.out","w",stdout);

    int l,r,x,y;
    n=readint();
    for(int i=1;i<=n;i++)
    {
        l=readint()+1;r=readint();
        a[i].l=l;a[i].r=r;
        b[++tot]=l;b[++tot]=r;
    }
    dis_init();
    for(int i=n;i>=1;i--)
    {
        x=a[i].l;y=a[i].r;
        po=y+1;
        if(check[po]!=0)
            po=find(po);
        while(x<=y)
        {
            if(check[x]!=0) x=find(x);
            else
            {
                if(flag[i]==false) ans++,flag[i]=true;
                check[x]=i;
                jump[x]=po;
                x++;
            }
        }   
    }
    printf("%d",ans);


    return 0;
}