Hdu4417_Super Mario(线段树+离线处理or划分树+二分)

题意：

给n个数，数中有重复的。有m个询问，问的是[L,R] 区间内有多少个数小于等于h

思路：

线段树+离线处理

这个题用线段树要离线处理（我试了一下在线的，超时了）。
先在原数组中存入n个高度和下标，按高度升序排序。
对于m此询问，先存储下来，注意存下标，然后按照高度升序排序。由于高度是从小到大的，没读入一个高度，在原数组里找所有比所查询高度小的，将他们在原数组中的下标置为1，然后就是线段树区间求和了。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define lson l, mid, root<<1
#define rson mid+1, r, root<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
const int maxn = 100000+5;

int Tree[maxn<<2], ans[maxn];
struct Node{
	int id, num;
	bool operator < (const Node& rhs) const{
		return num < rhs.num;
	}
}A[maxn];
struct query{
	int id, l, r, h;
	bool operator < (const query& rhs) const{
		return h < rhs.h;
	}
}q[maxn];


void push_up(int rt){
	Tree[rt] = Tree[rt<<1] + Tree[rt<<1|1];
}
void update(int k, int l, int r, int root){
	if(l == r){
		Tree[root] = 1;
		return;
	}
	int mid = (l+r) >> 1;
	if(k <= mid) update(k, lson);
	else update(k, rson);
	push_up(root);
}

int Query(int la, int rb, int l, int r, int root){
	if(la <= l&&rb >= r) return Tree[root];
	int mid = (l+r) >> 1, ans = 0;
	if(la <= mid) ans+= Query(la, rb, lson);
	if(rb > mid) ans+= Query(la, rb, rson);
	return ans;
}

int main()
{
	freopen("in.txt","r",stdin);
	int n, m;
	int T; scanf("%d", &T);
	for(int kase = 1; kase <= T; ++kase){
		memset(Tree, 0, sizeof(Tree));
		printf("Case %d:\n", kase);		// 这里不要再++了，哎呦！ 
		scanf("%d%d", &n,&m);
		
		for(int i = 1; i <= n; ++i){
			scanf("%d", &A[i].num);
			A[i].id = i;
		}
		for(int i = 1; i <= m; ++i){
			scanf("%d%d%d", &q[i].l, &q[i].r, &q[i].h);
			q[i].id = i;
		}
		sort(A+1, A+n+1);
		sort(q+1, q+m+1);
		
		int cnt = 1;
		for(int i = 1; i <= m; ++i){
			while(cnt <= n&&A[cnt].num <= q[i].h){
				update(A[cnt].id, 1, n, 1);
				++cnt;
			}
			ans[q[i].id] = Query(q[i].l+1, q[i].r+1, 1, n, 1);
		}
		for(int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
	}

	return 0;
}

划分树+二分

划分树可以方便求出【l, r】区间内的第k小的数。那么可以二分来求高度h在区间【l, r】上有多少比他小的。具体就是每次试探h是第几小。

// 划分树 
#include <cstdio>
#include <cstring>
#include <algorithm>
#define lson l, mid, root<<1
#define rson mid+1, r, root<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
const int maxn = 1e5+5;
int n, m;
int sorted[maxn], Tree[20][maxn], num[20][maxn];

void Build(int l, int r, int level){
	if(l == r) return;
	int mid = (l+r) >> 1, isame = mid-l+1;
	for(int i = l; i <= r; ++i) if(Tree[level][i] < sorted[mid]) --isame;
	int ls = l, rs = mid+1;
	for(int i = l; i <= r; ++i){
		if(i == l) num[level][i] = 0;
		else num[level][i] = num[level][i-1];
		if(Tree[level][i] < sorted[mid]||(Tree[level][i] == sorted[mid]&&isame > 0)){
			Tree[level+1][ls++] = Tree[level][i];
			++num[level][i];
			if(Tree[level][i] == sorted[mid]) --isame;
		}
		else
			Tree[level+1][rs++] = Tree[level][i];
	}
	Build(l, mid, level+1);
	Build(mid+1, r, level+1);
}

// 查询若把[la, rb]区间升序排列，第k个数是谁 
int Query(int la, int rb, int l, int r, int level, int k){
	if(l == r) return Tree[level][l];
	int ly;
	if(la == l) ly = 0;
	else ly = num[level][la-1];
	int tolef = num[level][rb] - ly;		// tolef个孩子走向左边 
	if(tolef >= k){
		return Query(l+ly, l+num[level][rb]-1, l, (l+r)>>1, level+1, k);
	}
	else{
		int rs = (l+r)/2 + 1 + (la - l - ly);
		return Query(rs, rs+rb-la+1-tolef-1, (l+r)/2+1, r, level+1, k-tolef); 
	}
}

int solve(int L, int R, int val){
	int l = 1, r = R-L+1;
	while(l <= r){
		int mid = (l+r) >> 1;
		int x = Query(L, R, 1, n, 0, mid);
		if(x <= val) l = mid+1;
		else r = mid-1;
	}
	return r;
}

int main()
{
	freopen("in.txt","r",stdin);
	int T; scanf("%d", &T);
	for(int kase = 1; kase <= T; ++kase){
		printf("Case %d:\n", kase);		// 这里不要再++了，哎呦！ 
		scanf("%d%d", &n,&m);
		
		for(int i = 1; i <= n; ++i){
			scanf("%d", &Tree[0][i]);
			sorted[i] = Tree[0][i];
		}
		sort(sorted+1, sorted+n+1);
		Build(1, n, 0);
		for(int i = 1; i <= m; ++i){
			int l,r,h; scanf("%d%d%d", &l, &r, &h);
			printf("%d\n", solve(l+1, r+1, h));
		}
	}
	fclose(stdin);
	return 0;
}

主席树

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
const int maxn = 100000+5;
int m;
int A[maxn], X[maxn];	// 原数组 和 离散化后的数组 
// 主席树 
int Tree[maxn*20];
int cnt;			// 每次新建的结点编号
int lson[maxn*20], rson[maxn*20]; //lson[x]和rson[x]是结点x的左右儿子结点的编号。
int root[maxn*20]; 	//第i棵线段树的根节点的编号

void Build(int& rt, int l, int r){
	rt = ++cnt; Tree[rt] = 0;
	if(l == r) return;
	int mid = (l+r) >> 1;
	Build(lson[rt], l, mid);
	Build(rson[rt], mid+1, r);
}

void update(int& new_rt, int old_rt, int l, int r, int pos){
	new_rt = ++cnt;
	lson[new_rt] = lson[old_rt]; rson[new_rt] = rson[old_rt];
	Tree[new_rt] = Tree[old_rt] + 1;
	if(l == r) return;
	int mid = (l+r) >> 1;
	if(pos <= mid) update(lson[new_rt], lson[old_rt], l, mid, pos);
	else update(rson[new_rt], rson[old_rt], mid+1, r, pos);
}

int Query(int la, int rb, int l, int r, int k){
	if(l == r) return X[l];
	int num = Tree[lson[rb]] - Tree[lson[la]];
	int mid = (l+r) >> 1;
	if(k <= num) return Query(lson[la], lson[rb], l, mid, k);
	else return Query(rson[la], rson[rb], mid+1, r, k-num);
}

int BS(int L, int R, int key){
	int l = 1, r = R-L+1;
	while(l <= r){
		int mid = (l+r) >> 1;
		int num = Query(root[L-1], root[R], 1, m, mid);// 脑抽写成Tree[]改了1个小时, woc 
		if(num <= key) l = mid + 1;
		else r = mid - 1;
	}
	return r;
}

int main()
{
	//freopen("E:/Cgit/Practice/ACM/in.txt","r",stdin);
	int kase = 1;
	int T, n, q; scanf("%d",&T);
	while(T--){
		scanf("%d%d",&n,&q);
		int tot = 0;
		for(int i = 1; i <= n; ++i) scanf("%d", &A[i]), X[++tot] = A[i];
		
		// 离散化
		sort(X+1, X+tot+1);
		m = 1;
		for(int i = 2; i <= n; ++i) if(X[i] != X[i-1]) X[++m] = X[i];
		
		// 建树
		cnt = 0;
		Build(root[0], 1, m);
		
		// n个数，n次插入更新，建立n个线段树 
		for(int i = 1; i <= n; ++i){
			int pos = lower_bound(X+1, X+m+1, A[i]) - X;
			update(root[i], root[i-1], 1, m, pos);
		}
		
		// 依次查询
		printf("Case %d:\n", kase++);
		while(q--){
			int x,y,z; scanf("%d%d%d", &x,&y,&z);
			printf("%d\n", BS(x+1, y+1, z));
		}
	}
	fclose(stdin);
	return 0;
}