hdu4417（Super Mario）—— 二分+划分树

Super Mario

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 9714    Accepted Submission(s): 4113

Problem Description

Mario is world-famous plumber. His “burly” figure and amazing jumping ability reminded in our memory. Now the poor princess is in trouble again and Mario needs to save his lover. We regard the road to the boss’s castle as a line (the length is n), on every integer point i there is a brick on height hi. Now the question is how many bricks in [L, R] Mario can hit if the maximal height he can jump is H.

 

Input

The first line follows an integer T, the number of test data.
For each test data:
The first line contains two integers n, m (1 <= n <=10^5, 1 <= m <= 10^5), n is the length of the road, m is the number of queries.
Next line contains n integers, the height of each brick, the range is [0, 1000000000].
Next m lines, each line contains three integers L, R,H.( 0 <= L <= R < n 0 <= H <= 1000000000.)

 

Output

For each case, output "Case X: " (X is the case number starting from 1) followed by m lines, each line contains an integer. The ith integer is the number of bricks Mario can hit for the ith query.

 

Sample Input

1

10 10

0 5 2 7 5 4 3 8 7 7

2 8 6

3 5 0

1 3 1

1 9 4

0 1 0

3 5 5

5 5 1

4 6 3

1 5 7

5 7 3

 

Sample Output

Case 1:

4

0

0

3

1

2

0

1

5

1

 

题意：给出n个数组成的无序序列，序列中的每个数表示一块砖的高度，有m个查询，每个查询三个数，前两个数表示序列的一个子区间，第三个数表示马里奥能跳到的最大高度，问你在这个子区间中，马里奥共能跳过多少个砖头。

题解：我们可以这么想，对于一个子区间，我们将它按从小到大排好序，然后对这个区间进行二分，找到这个区间排序后的中间值，若马里奥能跳过的最大高度大于中间值，则可得知马里奥可以跳过排序后区间的前半段，然后对区间后边段进行二分；若最大高度小于中间值，则对排序后区间前半部分进行二分，一直持续二分下去,直到结束。最终二分的停止位置就是可以被跳过的砖的数量。

　　而每次查询都对子区间进行排序的话时间复杂度太高，所以我们可以用划分树对区间进行维护。划分树的作用就是查找区间当中的第k大的值，这里我就不讲解划分树了，不会的可以先去学一学。每次二分都用划分树找出当前的第mid个值，然后与马里奥能跳过的最大值进行比较。

 

具体看代码：

 #include<iostream>
 #include<iomanip>
 #include<cstring>
 #include<cstdio>
 #include<string>
 #include<cmath>
 #include<algorithm>
 #include<fstream>
 #include<stack>
 #include<climits>
 #include<queue>
 #define eps 1e-7
 //#define ll long long
 #define inf 0x3f3f3f3f
 #define pi 3.141592653589793238462643383279
 using namespace std;
 const int MAXN = 1e5 + ;
 int n,m,tree[][MAXN],sorted[MAXN],toleft[][MAXN];

 void build(int l,int r,int dep)  //建立划分树
 {
     if(l == r) return;

     int mid = (l + r)>>;
     int lpos = l;
     int rpos = mid + ;
     int same = mid - l + ;
     for(int i=l; i<=r; ++i)
         if(tree[dep][i] < sorted[mid])
             same--;

     for(int i=l; i<=r; ++i)
     {
         if(tree[dep][i] < sorted[mid])
             tree[dep+][lpos++] = tree[dep][i];
         else if(tree[dep][i] == sorted[mid] && same > )
         {
             tree[dep+][lpos++] = tree[dep][i];
             same--;
         }
         else tree[dep+][rpos++] = tree[dep][i];
         toleft[dep][i] = toleft[dep][l-] + lpos - l;
     }

     build(l,mid,dep+);
     build(mid+,r,dep+);
 }

 int query(int l,int r,int L,int R,int dep,int k)  //划分树查询区间第k大值
 {
     if(l == r)
         return tree[dep][l];
     int mid = (L + R) >> ;
     int cnt = toleft[dep][r] - toleft[dep][l-];

     int newl,newr;
     if(cnt >= k)
     {
         newl = L + toleft[dep][l-] - toleft[dep][L-];
         newr = newl + cnt - ;
         return query(newl,newr,L,mid,dep+,k);
     }
     else
     {
         newr = r + (toleft[dep][R] - toleft[dep][r]);
         newl = newr - r + l + cnt;
         return query(newl,newr,mid+,R,dep+,k - cnt);
     }
 }

 int solve(int ll,int rr,int h)    //计算区间当中可以被跳过的砖头的数量
 {
     int l = ,r = (rr-ll) + ,ans=;
     while(l <= r)
     {
         int mid = (l + r) >> ;  //取当前区间的中间值下标
         if(query(ll,rr,,n,,mid) <= h)  //划分树查询得到中间值，若中间值 <= h
         {
             l = mid + ; //缩小区间
             ans = mid;
         }
         else r = mid - ;
     }
     return ans;
 }

 int main()
 {
     int t,cnt = ;
     cin>>t;
     while(t--)
     {
         cin>>n>>m;
         for(int i=; i<=n; ++i)
         {
             scanf("%d",&sorted[i]);
             tree[][i] = sorted[i];
         }
         sort(sorted+, sorted++n);
         build(,n,);

         printf("Case %d:\n",++cnt);
         int l,r,h;
         while(m--)
         {
             scanf("%d%d%d",&l,&r,&h);
             printf("%d\n",solve(l+,r+,h));
         }
     }
     return ;
 }