hdu4417Super Mario(线段树+离线处理)

->题目请戳这里<-

题目大意：一个长为n的路，每个整点处有高度为h的墙，现在超级玛丽要跳过这些墙去救公主。给m个询问，每个询问包含询问区间a-b以及玛丽的弹跳高度c，求对于每个询问，玛丽能跳过这个区间多少墙。

题目分析：简单的说就是求给定区间不大于c的墙的个数。对区间处理很容易想到线段树，但是线段树貌似没有查询区间小于某个数的个数的功能，又像划分树，但是划分树求的是区间第k大值。所以我们换一下思路。我们先把所有的墙升序排列，同时要记录下每个墙的位置，然后对所有询问，我们也按询问高度升序排列，然后线性扫描每个墙，如果墙的高度小于当前询问高度，那么将墙插入原来的位置，如果当前要插入的墙高度大于当前要询问的高度，那么执行查询操作，因为此时插入的墙高度一定小于当前询问高度，那么一查询，找到的就是当前查询区间中不大于当前查询高度的墙的个数，然后将查询结果保存起来，最后依次输出查询结果即可。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100005;
int m,n;
int ans[N];
struct node
{
    int l,r,h,id;
}ask[N];
struct nd
{
    int pos,h;
}brick[N];
int tree[N<<2];

int cmp1(struct nd a,struct nd b)
{
    return a.h < b.h;
}

int cmp2(struct node a,struct node b)
{
    return a.h < b.h;
}

void build(int num,int s,int e)
{
    tree[num] = 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 pos)
{
    if(s == e)
    {
        tree[num] = 1;
        return;
    }
    int mid = (s + e)>>1;
    if(pos <= mid)
        insert(num<<1,s,mid,pos);
    else
        insert(num<<1|1,mid + 1,e,pos);
    tree[num] = tree[num<<1] + tree[num<<1|1];
}

int query(int num,int s,int e,int l,int r)
{
    if(s == l && e == r)
        return tree[num];
    int mid = (s + e)>>1;
    if(r <= mid)
        return query(num<<1,s,mid,l,r);
    else
    {
        if(l > mid)
            return query(num<<1|1,mid + 1,e,l,r);
        else
            return query(num<<1,s,mid,l,mid) + query(num<<1|1,mid + 1,e,mid + 1,r);
    }
}

int main()
{
    int t,m,n,i;
    int cas = 0;
    scanf("%d",&t);
    while(t --)
    {
        scanf("%d%d",&n,&m);
        for(i = 1;i <= n;i ++)
        {
            scanf("%d",&brick[i].h);
            brick[i].pos = i;
        }
        for(i = 1;i <= m;i ++)
        {
            scanf("%d%d%d",&ask[i].l,&ask[i].r,&ask[i].h);
            ask[i].id = i;
            ask[i].l ++;
            ask[i].r ++;
        }
        sort(brick + 1,brick + n + 1,cmp1);
        sort(ask + 1,ask + m + 1,cmp2);
        printf("Case %d:\n",++cas);
        memset(tree,0,sizeof(tree));
        //build(1,1,n);
        int j = 1;
        for(i = 1;i <= n;)
        {
            if(brick[i].h > ask[j].h)
            {
                ans[ask[j].id] = query(1,1,n,ask[j].l,ask[j].r);
                j ++;
                if(j > m)
                    break;
            }
            else
            {
                insert(1,1,n,brick[i].pos);
                i ++;
            }
        }
        for(;j <= m;j ++)
            ans[ask[j].id] = query(1,1,n,ask[j].l,ask[j].r);
        for(i = 1;i <= m;i ++)
            printf("%d\n",ans[i]);
    }
    return 0;
}
//265MS	3628K

这题用划分树也是可以的，划分树求的是任意区间第k大值，那么二分枚举该区间的第k大值，使之不大于给定高度，那么也能求出结果。代码以后再贴。