poj2528Mayor's posters

题目链接：http://poj.org/problem?id=2528

区间覆盖。

离散化（有点特殊的离散化）。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;

const int maxn=11111;
int cnt;
int f[maxn<<4];
int li[maxn],ri[maxn];
int has[maxn],X[maxn<<3];

void pushdown(int rt)
{
    if(f[rt]!=-1)
    {
        f[rt<<1]=f[rt<<1|1]=f[rt];
        f[rt]=-1;
    }
}

void update(int L,int R,int c,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        f[rt]=c;
        return ;
    }
    int m=(l+r)>>1;
    pushdown(rt);
    if(L<=m) update(L,R,c,lson);
    if(m<R) update(L,R,c,rson);
}
void query(int l,int r,int rt)
{
    if(f[rt]!=-1)
    {
        if(!has[f[rt]]) cnt++;
        has[f[rt]]=1;
        return;
    }
    if(l==r) return;
    int m=(l+r)>>1;
    query(lson);
    query(rson);
}
int bin(int x,int n,int X[])
{
    int l=0,r=n-1;
    while(l<=r){
    int m=(l+r)>>1;
    if(X[m]==x) return m;
    if(X[m]>x) r=m-1;
    else l=m+1;
    }
    return -1;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        int nn=0;
        for(int i=0;i<n;i++){
            scanf("%d%d",&li[i],&ri[i]);
            X[nn++]=li[i];
            X[nn++]=ri[i];
        }
        sort(X,X+nn);
        int m=1;
        for(int i=1;i<nn;i++)
        {
            if(X[i]!=X[i-1]) X[m++]=X[i];
        }
        for(int i=m-1;i>0;i--)
        {
            if(X[i]!=X[i-1]+1) X[m++]=X[i-1]+1;
        }
        sort(X,X+m);
        memset(f,-1,sizeof(f));
        for(int i=0;i<n;i++)
        {
            int L=bin(li[i],m,X);
            int R=bin(ri[i],m,X);
            update(L,R,i,0,m,1);
        }
        memset(has,0,sizeof(has));
        cnt=0;
        query(0,m,1);
        printf("%d
",cnt);
    }
    return 0;
}

很久之前做的一道题，一直有些地方很纠结。。。

今天在hiho上看到了，用上面那种离散化竟然错了。。。

学习了新姿势。。。

想起来之前在哪看的一句话，人家三天就能学到线段树的精髓，你几个月还学得稀里糊涂。。大概说的就是我了。。。

题目链接：hiho1079

在线段树的通常用法中，线段树的节点是有2种不同的意义的，一种是离散型的，比如在Hiho一下 第二十周中，一个节点虽然描述的是一个区间[3, 9]，但是实际上这样一个区间是{3, 4, 5, 6, 7, 8, 9}这样的意义。而另一种就是连续型的，比如就在这一周的问题中，一个节点如果描述的是一个区间[3, 9]，它就确确实实描述的是在数轴上从3这个标记到9这个标记的这一段。

这两种不同的意义有什么区别呢？

在小Hi看来，其实只有这样的几个区别：1.叶子节点：在离散型中，叶子节点是[i, i]，而连续性中是[i, i + 1]；2.分解区间：在离散型中，一段区间是分解成为[l, m], [m + 1, r]，而在连续型中，是分解成为[l, m], [m, r]；3.其他所有类似的判定问题。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=100010;
int f[maxn<<4];
#define lson l,m,rt<<1
#define rson m,r,rt<<1|1
int li[maxn],ri[maxn];
int X[maxn<<3];
int has[maxn];
int n,lo;
int ct=0;
int ans=0;


void pushdown(int rt)
{
    if(f[rt]!=-1)
    {
        f[rt<<1|1]=f[rt<<1]=f[rt];
        f[rt]=-1;
    }
}

void update(int L,int R,int id,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        f[rt]=id;
        return;
    }
    int m=(l+r)>>1;
    pushdown(rt);
    if(L<m) update(L,R,id,lson);  //连续
    if(R>m) update(L,R,id,rson);
}
void query(int l,int r,int rt)
{
    if(f[rt]!=-1)
    {
        if(!has[f[rt]]) ans++;
        has[f[rt]]=1;
        return;
    }
    if(l+1==r) return;  //连续区间的返回条件
    int m=(l+r)>>1;
    query(lson);
    query(rson);
}

int Bin(int x,int len,int *X)
{
    int l=0,r=len;
    while(l<=r)
    {
        int m=(l+r)>>1;
        if(X[m]==x) return m;
        if(X[m]>x) r=m-1;
        else l=m+1;
    }
    return -1;
}
int main()
{
    scanf("%d%d",&n,&lo);
    for(int i=0;i<n;i++)
    {
        scanf("%d%d",&li[i],&ri[i]);
        X[ct++]=li[i];
        X[ct++]=ri[i];
    }
    sort(X,X+ct);
    int m=1;
    for(int i=1;i<ct;i++) if(X[i]!=X[i-1]) X[m++]=X[i];  //离散化
    m--;
    memset(f,-1,sizeof(f));
    for(int i=0;i<n;i++)
    {
        int L=Bin(li[i],m,X);
        int R=Bin(ri[i],m,X);
        update(L,R,i,0,m,1);
    }
    memset(has,0,sizeof(has));
    query(0,m,1);
    printf("%d
",ans);
}

---

---

 再次更新。。。

是读题读错了ozr，题目说的线段并不是线段，它是用一个编号表示一个线段，所以本质上当成点做就可以了。。。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=100010;
int f[maxn<<4];
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int li[maxn],ri[maxn];
int X[maxn<<3];
int has[maxn];
int n,lo;
int ct=0;
int ans=0;


void pushdown(int rt)
{
    if(f[rt]!=-1)
    {
        f[rt<<1|1]=f[rt<<1]=f[rt];
        f[rt]=-1;
    }
}

void update(int L,int R,int id,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        f[rt]=id;
        return;
    }
    int m=(l+r)>>1;
    pushdown(rt);
    if(L<=m) update(L,R,id,lson);  //连续
    if(R>m) update(L,R,id,rson);
}
void query(int l,int r,int rt)
{
    if(f[rt]!=-1)
    {
        if(!has[f[rt]]) ans++;
        has[f[rt]]=1;
        return;
    }
    if(l==r) return;  //连续区间的返回条件
    int m=(l+r)>>1;
    query(lson);
    query(rson);
}

int Bin(int x,int len,int *X)
{
    int l=0,r=len;
    while(l<=r)
    {
        int m=(l+r)>>1;
        if(X[m]==x) return m;
        if(X[m]>x) r=m-1;
        else l=m+1;
    }
    return -1;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d%d",&li[i],&ri[i]);
        X[ct++]=li[i];
        X[ct++]=ri[i];
    }
    sort(X,X+ct);
    int m=1;
    for(int i=1;i<ct;i++) if(X[i]!=X[i-1]) X[m++]=X[i];  //离散化
    m--;
    memset(f,-1,sizeof(f));
    for(int i=0;i<n;i++)
    {
        int L=Bin(li[i],m,X);
        int R=Bin(ri[i],m,X);
        update(L,R,i,0,m,1);
    }
    memset(has,0,sizeof(has));
    ans=0;
    query(0,m,1);
    printf("%d
",ans);
    }
}