hdu 3473 （划分树）2

Minimum Sum

Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 4611    Accepted Submission(s): 1046

Problem Description

You are given N positive integers, denoted as x0, x1 ... xN-1. Then give you some intervals [l, r]. For each interval, you need to find a number x to make as small as possible!

 

Input

The first line is an integer T (T <= 10), indicating the number of test cases. For each test case, an integer N (1 <= N <= 100,000) comes first. Then comes N positive integers x (1 <= x <= 1,000, 000,000) in the next line. Finally, comes an integer Q (1 <= Q <= 100,000), indicting there are Q queries. Each query consists of two integers l, r (0 <= l <= r < N), meaning the interval you should deal with.

 

Output

For the k-th test case, first output “Case #k:” in a separate line. Then output Q lines, each line is the minimum value of . Output a blank line after every test case.

 

Sample Input

2

5
3 6 2 2 4
2
1 4
0 2

2
7 7
2
0 1
1 1

 

Sample Output

Case #1:
6
4

Case #2:
0
0

 

Author

standy

 

 

裸题我都不会  我废了

 

现在还是懵逼状态

 

ans=  【L，R 】  （中位数左边的值-中位数右边的值 ） 如果 注意一下这个区间元素的个数

用一个sum数组累加  

当进入左子树查找时ans+=查询区间进入右子树的元素和

当进入右子树查询时ans-=查询区间进入左子树的元素和。

 

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 using namespace std;
 typedef long long LL;
 const int maxn = 1e5 + ;
 int sorted[maxn];
 int num[][maxn], val[][maxn];
 LL sum[][maxn];

 void build(int l, int r, int dep) {
     if (l == r) {
         sum[dep][l] = sum[dep][l - ] + val[dep][l];
         return ;
     }
     int mid = (l + r) >> , same = mid - l + ;
     for (int i = l ; i <= r ; i++) {
         if (val[dep][i] < sorted[mid]) same--;
         sum[dep][i] += sum[dep][i - ] + val[dep][i];
     }
     int lpos = l, rpos = mid + ;
     for (int i = l ; i <= r ; i++) {
         if (val[dep][i] < sorted[mid]) val[dep + ][lpos++] = val[dep][i];
         else if (val[dep][i] == sorted[mid] && same > ) {
             val[dep + ][lpos++] = val[dep][i];
             same--;
         } else val[dep + ][rpos++] = val[dep][i];
         num[dep][i] = num[dep][l - ] + lpos - l;
     }
     build(l, mid, dep + ) ;
     build(mid + , r, dep + );
 }
 LL ans;

 int query(int L, int R, int l, int r, int dep, int k) {
     if (l == r) return val[dep][l];
     int mid = (L + R) >> ;
     int cnt = num[dep][r] - num[dep][l - ];
     if (cnt >= k) {
         int ee = r - L +  - (num[dep][r] - num[dep][L - ]) + mid;
         int ss = l - L - (num[dep][l - ] - num[dep][L - ]) + mid;
         ans += sum[dep + ][ee] - sum[dep + ][ss];
         int newl = L + num[dep][l - ] - num[dep][L - ];
         int newr = newl + cnt - ;
         return query(L, mid, newl, newr, dep + , k);
     } else {
         int s = L + num[dep][l - ] - num[dep][L - ];
         int e = s + cnt - ;
         ans -= sum[dep + ][e] - sum[dep + ][s - ];
         int newr = r + num[dep][R] - num[dep][r];
         int newl = newr - (r - l +  - cnt) + ;
         return query(mid + , R, newl, newr, dep + , k - cnt);
     }
 }

 int main() {
     int t, n, cas = , m, l, r;
     scanf("%d", &t);
     while(t--) {
         scanf("%d", &n);
         memset(val, , sizeof(val));
         memset(sum, , sizeof(sum));
         for (int i =  ; i <= n ; i++)  {
             scanf("%d", &val[][i]);
             sorted[i] = val[][i];
         }
         sort(sorted + , sorted + n + );
         build(, n, );
         printf("Case #%d:\n", cas++);
         scanf("%d", &m);
         while(m--) {
             scanf("%d%d", &l, &r);
             ans = ;
             l++, r++;
             int temp = query(, n, l, r, , (l + r) /  - l + );
             if ((l + r) % ) ans -= temp;
             printf("%lld\n", ans);
         }
         printf("\n");
     }
     return ;
 }