poj 2528 Mayor's posters 线段树+离散化 || hihocode #1079 离散化

Mayor's posters

Description

The citizens of Bytetown, AB, could not stand that the candidates in the mayoral election campaign have been placing their electoral posters at all places at their whim. The city council has finally decided to build an electoral wall for placing the posters and introduce the following rules: 

• Every candidate can place exactly one poster on the wall. 
• All posters are of the same height equal to the height of the wall; the width of a poster can be any integer number of bytes (byte is the unit of length in Bytetown). 
• The wall is divided into segments and the width of each segment is one byte. 
• Each poster must completely cover a contiguous number of wall segments.

They have built a wall 10000000 bytes long (such that there is enough place for all candidates). When the electoral campaign was restarted, the candidates were placing their posters on the wall and their posters differed widely in width. Moreover, the candidates started placing their posters on wall segments already occupied by other posters. Everyone in Bytetown was curious whose posters will be visible (entirely or in part) on the last day before elections. 
Your task is to find the number of visible posters when all the posters are placed given the information about posters' size, their place and order of placement on the electoral wall. 

Input

The first line of input contains a number c giving the number of cases that follow. The first line of data for a single case contains number 1 <= n <= 10000. The subsequent n lines describe the posters in the order in which they were placed. The i-th line among the n lines contains two integer numbers l_i and ri which are the number of the wall segment occupied by the left end and the right end of the i-th poster, respectively. We know that for each 1 <= i <= n, 1 <= l_i <= ri <= 10000000. After the i-th poster is placed, it entirely covers all wall segments numbered l_i, l_i+1 ,... , ri.

Output

For each input data set print the number of visible posters after all the posters are placed. 

The picture below illustrates the case of the sample input. 

Sample Input

1
5
1 4
2 6
8 10
3 4
7 10

Sample Output

4

Source

Alberta Collegiate Programming Contest 2003.10.18

思路：离散化+树状数组；

ps：poj的离散化这题数据弱；

　　给个样例；

　　1

      3

      1 4

      1 2

      3 4

　　答案应该是3吧；

     所以在长度为1的离散化中间需要再添加一个数；

　　我的处理是在每个数后面再加一个相同的数；

　　hiho的数据蛮强的；本人poj的代码有误懒得改了。虽然ac了；

　　可以看我hiho的代码，差不多；

#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define mod 1000000007
#define pi (4*atan(1.0))
const int N=1e5+10,M=1e6+10,inf=1e9+10;
int sum[N*4],lazy[N*4];
set<int>s;
set<int>::iterator it;
void pushdown(int pos,int len)
{
    int lson=pos*2;
    int rson=pos*2+1;
    if(lazy[pos])
    {
        lazy[lson]=lazy[pos];
        lazy[rson]=lazy[pos];
        sum[lson]=lazy[pos];
        sum[rson]=lazy[pos];
        lazy[pos]=0;
    }
}
void buildtree(int l,int r,int pos)
{
    lazy[pos]=0;
    sum[pos]=0;
    int mid=(l+r)>>1;
    if(l==r)
    return;
    buildtree(l,mid,pos*2);
    buildtree(mid+1,r,pos*2+1);
}
void query(int l,int r,int pos)
{
    pushdown(pos,r-l+1);
    if(l==r)
    {
        if(sum[pos])
        s.insert(sum[pos]);
        return;
    }
    int mid=(l+r)>>1;
    query(l,mid,pos*2);
    query(mid+1,r,pos*2+1);
}
void update(int L,int R,int c,int l,int r,int pos)
{
    if(L<=l&&r<=R)
    {
        lazy[pos]=c;
        sum[pos]=c;
        return;
    }
    pushdown(pos,(r-l+1));
    ll mid=(l+r)>>1;
    if(L<=mid)update(L,R,c,l,mid,pos*2);
    if(mid<R)update(L,R,c,mid+1,r,pos*2+1);
}
struct is
{
    int l,r;
}a[N<<2];
int num[N<<2];
int main()
{
    int x,y,z,i,t;
    int T;
    scanf("%d",&T);
    while(T--)
    {
        buildtree(1,50000,1);
        s.clear();
        int ji=0;
        scanf("%d",&x);
        for(i=0;i<x;i++)
        {
            scanf("%d%d",&a[i].l,&a[i].r);
            num[ji++]=a[i].l;
            num[ji++]=a[i].r;
        }
        sort(num,num+ji);
        ji=1;
        for(i=1;i<2*x;i++)
        if(num[i]!=num[ji-1])
        num[ji++]=num[i];
        for(i=0;i<x;i++)
        {
            int l=lower_bound(num,num+ji,a[i].l)-num;
            int r=lower_bound(num,num+ji,a[i].r)-num;
            update(l+1,r+1,i+1,1,50000,1);
        }
        query(1,50000,1);
        printf("%d
",s.size());
    }
    return 0;
}

#1079 : 离散化

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi和小Ho在回国之后，重新过起了朝7晚5的学生生活，当然了，他们还是在一直学习着各种算法~

这天小Hi和小Ho所在的学校举办社团文化节，各大社团都在宣传栏上贴起了海报，但是贴来贴去，有些海报就会被其他社团的海报所遮挡住。看到这个场景，小Hi便产生了这样的一个疑问——最后到底能有几张海报还能被看见呢？

于是小Ho肩负起了解决这个问题的责任：因为宣传栏和海报的高度都是一样的，所以宣传栏可以被视作长度为L的一段区间，且有N张海报按照顺序依次贴在了宣传栏上，其中第i张海报贴住的范围可以用一段区间[a_i, b_i]表示，其中a_i, b_i均为属于[0, L]的整数，而一张海报能被看到当且仅当存在长度大于0的一部分没有被后来贴的海报所遮挡住。那么问题就来了：究竟有几张海报能被看到呢？

提示一：正确的认识信息量

提示二：小Hi大讲堂之线段树的节点意义

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为两个整数N和L，分别表示总共贴上的海报数量和宣传栏的宽度。

每组测试数据的第2-N+1行，按照贴上去的先后顺序，每行描述一张海报，其中第i+1行为两个整数a_i, b_i，表示第i张海报所贴的区间为[a_i, b_i]。

对于100%的数据，满足N<=10^5，L<=10^9，0<=a_i<b_i<=L。

输出

对于每组测试数据，输出一个整数Ans，表示总共有多少张海报能被看到。

样例输入

5 10
4 10
0 2
1 6
5 9
3 4

样例输出

5

#include<iostream>
#include<cstdio>
#include<cmath>
#include<string>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstring>
#include<vector>
#include<list>
#include<set>
#include<map>
using namespace std;
#define ll long long
#define mod 1000000007
#define pi (4*atan(1.0))
const int N=1e5+10,M=1e6+10,inf=1e9+10;
int sum[M*2],lazy[M*2];
set<int>s;
void pushdown(int pos,int len)
{
    int lson=pos*2;
    int rson=pos*2+1;
    if(lazy[pos])
    {
        lazy[lson]=lazy[pos];
        lazy[rson]=lazy[pos];
        sum[lson]=lazy[pos];
        sum[rson]=lazy[pos];
        lazy[pos]=0;
    }
}
void buildtree(int l,int r,int pos)
{
    lazy[pos]=0;
    sum[pos]=0;
    int mid=(l+r)>>1;
    if(l==r)
    return;
    buildtree(l,mid,pos*2);
    buildtree(mid+1,r,pos*2+1);
}
void query(int l,int r,int pos)
{
    pushdown(pos,r-l+1);
    if(l==r)
    {
        if(sum[pos])
        s.insert(sum[pos]);
        return;
    }
    int mid=(l+r)>>1;
    query(l,mid,pos*2);
    query(mid+1,r,pos*2+1);
}
void update(int L,int R,int c,int l,int r,int pos)
{
    pushdown(pos,(r-l+1));
    if(L<=l&&r<=R)
    {
        lazy[pos]=c;
        sum[pos]=c;
        return;
    }
    int mid=(l+r)>>1;
    if(L<=mid)update(L,R,c,l,mid,pos*2);
    if(mid<R)update(L,R,c,mid+1,r,pos*2+1);
}
struct is
{
    int l,r;
}a[M*2];
int num[M*2];
int lisan[M*2];
int main()
{
    int x,y,z,i,t;
    while(~scanf("%d%d",&x,&y))
    {
        s.clear();
        int ji=0;
        for(i=0;i<x;i++)
        {
            scanf("%d%d",&a[i].l,&a[i].r);
            num[ji++]=a[i].l;
            num[ji++]=a[i].r;
        }
        sort(num,num+ji);
        ji=1;
        for(i=1;i<2*x;i++)
        if(num[i]!=num[i-1])
        num[ji++]=num[i];
        int gg=0;
        for(i=0;i<ji;i++)
        {
            lisan[gg++]=num[i];
            lisan[gg++]=num[i];
        }
        buildtree(1,gg+100,1);
        for(i=0;i<x;i++)
        {
            int l=lower_bound(lisan,lisan+gg,a[i].l)-lisan;
            int r=lower_bound(lisan,lisan+gg,a[i].r)-lisan;
            update(l+1,r+1,i+1,1,gg+100,1);
        }
        query(1,gg+100,1);
        printf("%d
",s.size());
    }
    return 0;
}