HDU-4417 (树状数组or线段树)-Super Mario

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4417

1.线段树+离散处理

这道题主要的地方就是离线处理数据，具体想法：

　　① 先把所有位置的高度都存下来，然后排序，注意保存下标；

　　② 把所有询问存下来，然后按照询问的高度进行排序，同注意保存下标；

　　③ 对于排序后的每次询问的处理：由于每个位置的高度都已经存了下来并且进行了排序，所以可以按照顺序将每个点插入到线段树的对应位置(保存的下标)，并更新线段树，直到要插入的位置的高度大于这次询问的高度H；最后处理区间查询，由于刚才已经把小于等于该次查询高度的位置都已经插入到了线段树中，所以询问的结果就是查询区间中被更新过的叶子节点的个数，也就是区间求和问题。

 

AC代码：

#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn = 100000 + 5;
struct Node {        //每个节点的信息
    int h , pos;
} a[maxn];
struct Section {    //每次查询的区间信息
    int L , R , H;
    int index;
} s[maxn];
bool cmp1(Node q1,Node q2)//根据高度排序
{
	return q1.h <q2.h ;
}
bool cmp2(Section p1,Section p2)//根据高度排序
{
	return p1.H <p2.H ;
}
int cnt[maxn << 2] , ans[maxn];
struct node{
	int right;
	int left;
	int mx;
}f[4*maxn];
void built(int ans,int l,int r)//建树
{
	f[ans].left =l;f[ans].right =r;
	f[ans].mx =0;
	if(l==r)
	{
		return;
	}
	int mid=(l+r)/2;
	built(ans<<1,l,mid);
	built(ans<<1|1,mid+1,r);
}
void update(int p , int l )//更新
{
    if(f[l].left ==p&&f[l].right ==p) {
        f[l].mx ++;
        return;
    }
    int m = (f[l].left  + f[l].right ) >> 1;
    if(p > m)       
        update(p , l<<1|1);
    else
        update(p , l<<1);
    f[l].mx =f[l<<1].mx +f[l<<1|1].mx ;
}
int query(int L , int R , int ans)
{
    if(L == f[ans].left  && R == f[ans].right ) {
        return f[ans].mx ;
    }
    int m = (f[ans].left + f[ans].right ) >> 1;
    if(L > m)
        return query(L , R , ans<<1|1);
    else if(R <= m)
        return query(L , R , ans<<1);
    else
        return query(L , m , ans<<1) + query(m+1 , R ,ans<<1|1);
}
int main()
{
    int T , i , j , n , m;
    cin >> T;
    for(int k = 1 ; k <= T ; k++)
    {
        printf("Case %d:\n" , k);
        scanf("%d %d" , &n , &m);
		built(1,1,n);
        for(i = 1 ; i <= n ; i++) {
            scanf("%d" , &a[i].h);
            a[i].pos = i;
        }
        for(i = 1 ; i <= m ; i++) {
            scanf("%d %d %d" , &s[i].L , &s[i].R , &s[i].H);
            s[i].index = i;
        }
        sort(a + 1 , a + n + 1,cmp1);
        sort(s + 1 , s + m + 1,cmp2);
        for(i = j = 1 ; i <= m ; i++) {     
            while(a[j].h <= s[i].H && j <= n) {
                update(a[j++].pos , 1 );//按照由小到大的顺序读入那一串高度，但是读入的时高度的编号（入读的序号）。
            }
            ans[s[i].index] = query(s[i].L + 1 , s[i].R + 1 , 1 );//计算时，已读入的那些高度都小于等于此高度。计算在此区间内的数量，即结果。
        }
        for(i = 1 ; i <= m ; i++)
            printf("%d\n" , ans[i]);
    }
    return 0;
}

2.树状数组 AC代码：

思路与线段树类似。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#define ll long long
using namespace std;
int t;
int n,m;
const int INF=1e5+5;
struct node{
	int di;
	int d;
}a[INF];
int c[INF],sum[INF];
bool cmp1(node p1,node p2)
{
	return p1.d <p2.d ;
}
struct Node{
	int from;
	int to;
	int h;
	int ii;
}f[INF];
bool cmp2(Node q1,Node q2)
{
	return q1.h <q2.h ;
}
int lowbit(int x)
{
	return x&(-x);
}
void update(int x)
{
	while(x<=n)
	{
		c[x]++;
		x=x+lowbit(x);
	}
}
int getsum(int x)
{
	int ans=0;
	while(x>0)
	{
		ans=ans+c[x];
		x=x-lowbit(x);
	}
	return ans;
}
int main()
{
	int i,j,k,val;
	cin>>t;
	int s=0;
	while(t--)
	{
		s++;
		scanf("%d%d",&n,&m);
		fill(c,c+n+1,0);
		for(i=1;i<=n;i++)
		{
			scanf("%d",&a[i].d );
			a[i].di =i;
		}
		sort(a+1,a+n+1,cmp1);
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&f[i].from ,&f[i].to,&f[i].h  );
			f[i].ii =i;
		}
		sort(f+1,f+m+1,cmp2);
		printf("Case %d:\n",s);
		for(i=1,j=1;i<=m;i++)
		{
			for(;j<=n&&a[j].d <=f[i].h ;j++)
			{
				update(a[j].di );
			}
			sum[f[i].ii ]=getsum(f[i].to+1  )-getsum(f[i].from  );
		}
		for(i=1;i<=m;i++)
		{
			printf("%d\n",sum[i]);
		}
	}
    return 0;
}