hdu 3473 Minimum Sum 划分树

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

题意：给定一个数组，有Q次的询问，每次询问的格式为(l,r)，表示寻找一个x，使得的值最小。N<=100000, Q <=100000.

思路：本题根据N，Q的数据规模就可以看出，我们需要寻找一种查询时间复杂度为O(logN)的算法，否则肯定会超时。首先可以简单地证明得出这个x的值一定是区间（l，r）的中位数的取值，这个证明也很容易证明，这里就不再证明了，而一个区间的中位数就是将这个区间排序之后的中间那个，也就是假设区间(l,r)长度为len ，则中位数就是该区间的第(len)/2-l+1小的元素，求一个区间的第K小元素的算法很自然地会想到划分树， 而且划分树的查询复杂度为：O(logn)，正好可以解决此题。

        算法确定了之后就是具体的实现过程了，普通的划分树求的是区间内的第k小的元素，而这题是要求差值，也就是说我们不但要求出区间的第k小的元素，还要求出所有比中位数小的数 lsum，当然比中位数大的数的和可以根据区间的数的总和和lsum求得，因此不需要额外求。这样我们只需要在划分树建树的时候增加一个lsum[ ][i] 数组就可以了， 这个数组保存的是，在deep层，第i个元素做的区间中，在i前面被划分到左子树的元素之和。这样我们就可以求出最后的解了。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef __int64 LL ;
#define L(r) ((r<<1)) 
#define R(r) ((r<<1)+1)
#define MID(l,r) ((l+r)>>1)
const int MAX = 21 ;
const int MAXN = 100000+10 ;
int T ,N , Q;
long s[MAXN] ;
int val[MAX][MAXN] ;
int tol[MAX][MAXN] ;

LL lsum[MAX][MAXN] ;
LL sum[MAXN] ;

struct Node{
	int l ,r ;	
}p[MAXN*5] ;

void Build(int idx,int deep,int l, int r){
	p[idx].l = l ; p[idx].r = r ;
	if(l == r)	return ;
	int mid = MID(l ,r);
	int lnum = mid - l + 1;
	int v = s[mid] ;
	for(int i=l;i<=mid;i++){
		if(val[deep][i] < v)	lnum -- ;
	}
	int lto,rto ;
	lto = rto = 0 ;
	for(int i=l;i<=r;i++){
		if(i == l){
			tol[deep][i] = 0 ;
			lsum[deep][i] = 0 ;
		}
		else{
			tol[deep][i] = tol[deep][i-1] ;
			lsum[deep][i] = lsum[deep][i-1] ;
		}
		if( val[deep][i] < v){
			tol[deep][i] ++ ;
			lsum[deep][i] += val[deep][i] ;
			val[deep+1][ l+lto++ ] = val[deep][i] ;
		}
		else if( val[deep][i] > v){
			val[deep+1][ mid+1+rto++ ] = val[deep][i] ;
		}
		else{
			if(lnum > 0){
				lnum -- ;
				tol[deep][i] ++ ;
				val[deep+1][ l+lto++ ] = val[deep][i] ;
				lsum[deep][i] += val[deep][i] ;
			}
			else{
				val[deep+1][ mid+1+rto++ ] = val[deep][i] ;
			}
		}
	}
	Build( L(idx) , deep+1 , l ,  mid ) ;
	Build( R(idx) , deep+1 , mid+1 , r ) ;	
} 
LL toleft ;

LL query(int idx, int deep , int l , int r , int k){
	if(l == r){
		return val[deep][l] ;
	}
	int s, ss ;
	LL sum1 ;
	if(l == p[idx].l){
		ss = 0 ;
		sum1 = 0 ;	
	} 
	else{
		ss = tol[deep][l-1] ;
		sum1 = lsum[deep][l-1] ;
	}
	s = tol[deep][r] - ss ;
	int mid = MID( p[idx].l , p[idx].r ) ;
	if(s >= k){
		return query( L(idx) , deep+1, p[idx].l+ss ,p[idx].l+tol[deep][r]-1 , k) ;			
	}
	else{
		int ee = l - p[idx].l - ss; 
		int e = r - l + 1 - s ; 
		toleft += ( lsum[deep][r] - sum1 ) ;
		return query( R(idx) , deep+1 , mid+1+ee , mid+ee+e ,k-s);	
	}	
}

void solve(){
	int a ,b ;
	int ans1 , k ,cas = 0;
	while(T--){
		++cas ;
		scanf("%d",&N);
		sum[0] = 0 ;
		for(int i=1;i<=N;i++){
			scanf("%d",&s[i]);
			val[1][i] = s[i] ;
			sum[i] = sum[i-1] + s[i] ;
		}
		std::sort(s+1,s+1+N);
		Build(1,1,1,N);
		scanf("%d",&Q);
		printf("Case #%d:\n",cas);
		for(int i=0;i<Q;i++){
			scanf("%d %d",&a,&b);
			a++ ; b ++ ;
			k = (a + b)/2 - a  + 1 ;
			toleft= 0 ;
			LL res = query(1,1,a,b,k);
			LL ans = res*(k-1) - toleft ;
			ans += ( sum[b] - sum[a-1] - toleft - res*(b-a+2-k) );
			printf("%I64d\n",ans);
		}		
		printf("\n");
	}
}
int main(){
	scanf("%d",&T);
	solve() ;
	return 0 ;
}