poj2528Mayor's posters(线段树+离散化+坑坑坑)

最新推荐文章于 2019-08-03 09:38:50 发布

ophunter

最新推荐文章于 2019-08-03 09:38:50 发布

阅读量1.4k

点赞数

分类专栏： # 数据结构 # 线段树文章标签：数据结构

本文链接：https://blog.csdn.net/ophunter_lcm/article/details/9058091

版权

数据结构同时被 2 个专栏收录

51 篇文章 0 订阅

订阅专栏

线段树

25 篇文章 0 订阅

订阅专栏

->题目请戳这里<-

这题是个巨坑！！

------题记

题目大意：一个长10^7左右的墙，上面要贴10^4左右的海报，所有海报与墙同高，现在给出n张海报长度范围，求贴完这n张海报后有多少张能看见。其中每张海报长度是整数，每张海报必须从整点位置开始贴。

题目分析：线段覆盖问题。给每张海报编号，在数轴上依次插入这n张海报，后面的海报覆盖掉前面的。这题的关键是墙太长了，如果建线段树空间会爆，考虑到海报数量有限，最多10000张，那么这10000张海报最多有20000个边界点，而我们只需要这20000个点就行了，其他的不用，所以解决方案是离散化。

吐槽：这题给了一个图示，图上画的明明白白清清楚楚的每张海报覆盖的是整段的元线段，而不是覆盖的整点，所以离散化的时候如果原来2个相邻的点之间相差1以上的话，中间是要插一个点作为分界的，这才是正确的离散化方法。但是写完一交返回WA，因为这题的后台数据就是按海报覆盖整点来处理的！！！太坑了，大半个下午就跪这上面了。。。。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
using namespace std;
const int N = 20005;
bool flag[N];
int n;
struct nd
{
    int l,r;
}edge[N];
int lcm[N + N + N];
struct node
{
    int lazy,val;
}tree[N<<3];
//map<int,int>point;//用map竟然TLE,LE,E.....
int ans;

int find(int x,int m)
{
    int l = 0;
    int r = m - 1;
    int mid;
    while(l <= r)
    {
        mid = (l + r)>>1;
        if(lcm[mid] == x)
            return mid + 1;
        else
        {
            if(lcm[mid] > x)
                r = mid - 1;
            else
                l = mid + 1;
        }
    }
    return -1;
}

void build(int num,int s,int e)
{
    tree[num].lazy = tree[num].val = 0;
    if(s == e)
        return;
    int mid = (s + e)>>1;
    build(num<<1,s,mid);
    build(num<<1|1,mid + 1,e);
}

void insert(int num,int s,int e,int l,int r,int id)
{
    if(s == l && e == r)
    {
        tree[num].lazy = 1;
        tree[num].val = id;
        return;
    }
    if(tree[num].lazy == 1)
    {
        tree[num<<1].lazy = tree[num<<1|1].lazy = 1;
        tree[num<<1].val = tree[num].val;
        tree[num<<1|1].val = tree[num].val;
        tree[num].lazy = 0;
        tree[num].val = 0;
    }
    int mid = (s + e)>>1;
    if(r <= mid)
        insert(num<<1,s,mid,l,r,id);
    else
    {
        if(l > mid)
            insert(num<<1|1,mid + 1,e,l,r,id);
        else
        {
            insert(num<<1,s,mid,l,mid,id);
            insert(num<<1|1,mid + 1,e,mid + 1,r,id);
        }
    }
}

void query(int num,int s,int e)
{
    if(s == e)
    {
        if(flag[tree[num].val] == 0)
        {
            flag[tree[num].val] = 1;
            ans ++;
        }
        return;
    }
    if(tree[num].lazy == 1)
    {
        if(flag[tree[num].val] == 0)
        {
            flag[tree[num].val] = 1;
            ans ++;
        }
        return;
    }
    int mid = (s + e)>>1;
    query(num<<1,s,mid);
    query(num<<1|1,mid + 1,e);
}

int main()
{
    int t,i;
    scanf("%d",&t);
    while(t --)
    {
        scanf("%d",&n);
        int pos = 0;
        memset(lcm,0,sizeof(lcm));
        //point.clear();
        for(i = 1;i <= n;i ++)
        {
            scanf("%d%d",&edge[i].l,&edge[i].r);
            lcm[pos ++] = edge[i].l;
            lcm[pos ++] = edge[i].r;
        }
        sort(lcm,lcm + pos);
        int newpos = 0;
        for(i = 1;i < pos;i ++)
            if(lcm[i] != lcm[newpos])
                lcm[++newpos] = lcm[i];
        //for(i = newpos;i > 0;i --)
         //   if(lcm[i] - lcm[i - 1] > 1)
          //      lcm[++newpos] = lcm[i - 1] + 1;//应该这样离散化的！！！
        sort(lcm,lcm + newpos + 1);
        newpos ++;//离散化后的点数
        build(1,1,newpos);
        for(i = 1;i <= n;i ++)
        {
            int l = find(edge[i].l,newpos);
            int r = find(edge[i].r,newpos);
            insert(1,1,newpos,l,r,i);
        }
        ans = 0;
        memset(flag,0,sizeof(flag));
        query(1,1,newpos);
        printf("%d\n",ans);
    }
    return 0;
}
//1016K	63MS
/*
10
2
1 10
1 4
4
6 10
1 10
1 4
5 10
5
1 4
2 6
8 10
3 4
7 10
3
1 4
5 10
1 10
3
1 4
6 10
1 10
3
1 10
1 3
6 10
*/

ps：比如最后一组数据，按题目图示理解的话应该输出3，但是要输出2才能过。。。