hdu -4325-Flowers(离散化 线段树)

http://acm.hdu.edu.cn/showproblem.php?pid=4325；

题目意思：

给你N个花开的时间段，然后在有M个时间点，问你在这个时间点有多少花开着。

昨天刚做的一个类似的题，用线段树加离散化，然后赶紧敲，然后错八次。

最后还是没做出来。

那么思路还是线段树加离散化。

题目给的每个花开花谢的范围很大，但花的数目只有1e5，很容易就想到了离散化，然后就是用线段树去处理，找每个花开的段，最后lazy下放到

每个时间点，这样就知道每个时间点开的花数。

这题大致思路是这样的，但你会发现M次查询时，有的时间点，你在离散化时，你没将它加入，所以你在离散化后的数组里找不到这个点。当时没想到将询问的点加入一起离散化，然后各种二分，然并ruan.。

下面给出代码：

/*sjy*/
#include<stdio.h>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<math.h>
void add(int l,int r,int k,int aa,int dd);
int kr(int n,int m,int t);
void lazy(int l,int r,int k);
int  findd(int l,int r,int k,int aa,int dd);
int cmp(const void*p,const void*q);
/*int er(int n,int m,int t);*/
typedef struct pp
{
    int x;
    int y;
}ss;
int N,M,V;
int tree[8*100005];//线段树数组
ss a[100005];
ss b[2*100005];
int c[2*100005];
/*int yk[2*100005];*/
int kp[100005];
using namespace std;
int main(void)
{
    int n,i,j,k,p,q,x,y,s;
    scanf("%d",&n);
    for(i=1; i<=n; i++)
    {
        memset(tree,0,sizeof(tree));
        scanf("%d %d",&N,&M);
        int cnt=0;
        int sum=-1;
        for(j=0; j<N; j++)
        {
            scanf("%d %d",&a[j].x,&a[j].y);
            b[cnt].x=a[j].x;
            cnt++;
            b[cnt].x=a[j].y;
            cnt++;
            if(sum<a[j].y)
            {
                sum=a[j].y;
            }
        }
        for(j=0;j<M;j++)
        {
            scanf("%d",&kp[j]);
            b[cnt++].x=kp[j];
        }//询问的点加入离散化
        qsort(b,cnt,sizeof(ss),cmp);//排序离散化
        int vv=0;
        c[vv]=0;
        int rr=0;
        for(j=1; j<cnt; j++)
        {
            if(b[j].x!=b[j-1].x)
            {
                vv++;
                c[j]=vv;
                rr=0;
                /*yk[j]=rr;*/
            }
            else
            {
                c[j]=vv;
                /*yk[j]=rr;*/
            }
        }
        for(j=0; j<N; j++)
        {
            x=kr(0,cnt-1,a[j].x);//二分找点
            y=kr(0,cnt-1,a[j].y);
            add(x,y,0,0,vv);//线段数更新加段
        }
        lazy(0,vv,0);printf("Case #%d:
",i);
        for(j=0;j<M;j++)
        {
            int uu=kr(0,cnt-1,kp[j]);
            int yy=findd(uu,uu,0,0,vv);//查询问的时间段因为为点所以l=r
            printf("%d
",yy);
        }

    }
    return 0;

}
void add(int l,int r,int k,int aa,int dd)//线段数更新
{
    if(l>dd||r<aa)
    {
        return ;
    }
    else if(l<=aa&&r>=dd)
    {
        tree[k]++;
    }
    else
    {
        add(l,r,2*k+1,aa,(aa+dd)/2);
        add(l,r,2*k+2,(aa+dd)/2+1,dd);
    }
}

void lazy(int l,int r,int k)//最后下放操作
{
    if(l==r)
    {
        return ;
    }
    else
    {
        tree[2*k+1]+=tree[k];
        tree[2*k+2]+=tree[k];
        lazy(l,(l+r)/2,2*k+1);
        lazy((l+r)/2+1,r,2*k+2);
    }
}


int  findd(int l,int r,int k,int aa,int dd)
{
    if(l>dd||r<aa)
    {
        return 0;
    }
    else if(l<=aa&&r>=dd)
    {
        return tree[k];
    }
    else
    {
        int nx=findd(l,r,2*k+1,aa,(aa+dd)/2);
        int ny=findd(l,r,2*k+2,(aa+dd)/2+1,dd);
        return nx+ny;
    }

}

/*int er(int n,int m,int t)
{
    int y=(n+m)/2;
    if(b[y].x==t)
    {
        return c[y];
    }
    if(m<n)
    {
        return -1;
    }
    if(m==n&&b[m].x!=t)
    {
        return -1;
    }

    else if(m-n==1&&b[n].x<=t&&b[m].x>=t)
    {
        V=yk[n];
        return c[n];
    }
    else if(b[y].x<t)
    {
        return er(y,m,t);
    }
    else return er(n,y,t);

}*/
int kr(int n,int m,int t)//二分找点
{
    int yy=(n+m)/2;
    if(b[yy].x==t)
    {
        return c[yy];
    }
    else if(b[yy].x>t)
    {
        return kr(n,yy-1,t);
    }
    else return kr(yy+1,m,t);
}
int cmp(const void*p,const void*q)
{
    ss*w=(ss*)p;
    ss*ww=(ss*)q;

     return w->x-ww->x;
}