1175 區間中第K大的數

題目連結：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1175&judgeId=649231
主席樹與普通線段樹的建樹方法有點不同，他只儲存他的左兒子和右兒子，以及這條路徑覆蓋了多少次
比如要找
1 2 3 3 4 5
這6個數[2,4]中第3大的數
先離散化，就只有5個數了，然後建一顆空的線段樹，每條路徑都是0，然後依次把 1 2 3 3 4 5 加進去，每加一個數，就多加線段樹上的一條路徑
①這是空樹：

②：然後把1加進去

③然後把2加進去

④然後把3加進去

⑤再加一個3進去

假如要求[2,4]這個區間的第3大的數，那麼就是用加入了4個數的線段樹來減去，加入了兩個數的線段樹的前面一個線段樹（類似於字首和那種sum[R]-sum[L-1]），就能得到這段區間有多少數了，並且大小順序是有的，數量也是有的

第4個線段樹最下面一層就是：1 1 2 0 0
第1個線段樹最下面一層就是：1 0 0 0 0
於是減完就是：0 1 2 0 0

我們查詢就是用這個東西來查詢的，之前一直沒理解好~

那麼要求第k小就是求字首和，看多少能達到k，而求第k大就是求字尾和，看多少能達到k

就像這樣，從左邊開始，當框起來的數的和達到了k，那就找到了

同理第k大，就從右邊開始框，框起來的數達到了k，那麼這個位置的數就是第 k大了

#include"bits/stdc++.h"
using namespace std;
const int maxn=5e4+5;
int a[maxn];
int data[maxn];//原始資料
int N,n,tot,Q;
vector<int>Root;//用來儲存加進去的每個數的頭節點是多少
int tree[maxn*30],Ls[maxn*30],Rs[maxn*30];
int Build(int L,int R)//對離散後的n個數先建一個空數
{
	int id=++tot;
	tree[id]=0;
	if(L==R)return id;
	int mid=L+R>>
 
1;
	Ls[id]=Build(L,mid);
	Rs[id]=Build(mid+1,R);
	return id;
}
void Update(int id1,int v)
{
	v=lower_bound(a+1,a+1+n,v)-a;	//找到這個數排在第幾
	int id2=++tot;				//新建一個root
	tree[id2]=tree[id1]+1;
	Root.push_back(id2);
	int L=1,R=n;
	while(L<R)
	{
		int mid=L+R>>1;
		if(v<=mid)			//說明這個數是在左邊
		{
			R=mid;
			Ls[id2]=++tot;
			Rs[id2]=Rs[id1];//繼承原來的右兒子
			id2=tot;
			id1=Ls[id1];//向左走 
		}
		else
		{
			L=mid+1;
			Rs[id2]=++tot;
			Ls[id2]=Ls[id1];
			id2=tot;
			id1=Rs[id1];//向右走 
		}
		tree[id2]=tree[id1]+1;//這條路徑上都加1 
	}
}
int query(int rt1,int rt2,int k)
{
	int id1=Root[rt1];
	int id2=Root[rt2];
	int L=1,R=n;
	while(L<R)
	{
		int mid=L+R>>1;
		//找第k個大的就先忘右邊走，找第k個小的就先往左邊走 
		int cnt=tree[Rs[id2]]-tree[Rs[id1]];//找第k大的就看Rs的，找第k小的就看Ls的 
		if(cnt>=k)//右邊有>=k個數 
		{
			L=mid+1;
			id1=Rs[id1];
			id2=Rs[id2];
		}
		else
		{
			k-=cnt;
			R=mid;
			id1=Ls[id1];
			id2=Ls[id2];
		}
	}
	return L;
}
int main()
{
	while(cin>>N)
	{
		Root.resize(1);
		tot=0;
		for(int i=1; i<=N; i++)
		{
			cin>>data[i];
			a[i]=data[i];
		}
		sort(a+1,a+1+N);
		n=unique(a+1,a+1+N)-(a+1);//離散化
		Root[0]=Build(1,n);
		for(int i=1;i<=N;i++)Update(Root[i-1],data[i]);
		cin>>Q;
        for(int i=1;i<=Q;i++)
        {
            int L,R,K;
            cin>>L>>R>>K;
            L++,R++;
            int pos=query(L-1,R,K);
            cout<<a[pos]<<endl;
        }
	}
}

poj 2104 第k小

只有查詢那裡有點不同

#include"iostream"
#include"vector"
#include"algorithm"
#include"cstdio"
using namespace std;
const int maxn=1e5+5;
int a[maxn];
int data[maxn];//原始資料
int N,n,tot,Q;
vector<int>Root;//用來儲存加進去的每個數的頭節點是多少
int tree[maxn*30],Ls[maxn*30],Rs[maxn*30];
int Build(int L,int R)//對離散後的n個數先建一個空數
{
	int id=++tot;
	tree[id]=0;
	if(L==R)return id;
	int mid=L+R>>1;
	Ls[id]=Build(L,mid);
	Rs[id]=Build(mid+1,R);
	return id;
}
void Update(int id1,int v)
{
	v=lower_bound(a+1,a+1+n,v)-a;	//找到這個數排在第幾
	int id2=++tot;				//新建一個root
	tree[id2]=tree[id1]+1;
	Root.push_back(id2);
	int L=1,R=n;
	while(L<R)
	{
		int mid=L+R>>1;
		if(v<=mid)			//說明這個數是在左邊
		{
			R=mid;
			Ls[id2]=++tot;
			Rs[id2]=Rs[id1];//繼承原來的右兒子
			id2=tot;
			id1=Ls[id1];//向左走
		}
		else
		{
			L=mid+1;
			Rs[id2]=++tot;
			Ls[id2]=Ls[id1];
			id2=tot;
			id1=Rs[id1];//向右走
		}
		tree[id2]=tree[id1]+1;//這條路徑上都加1
	}
}
int query(int rt1,int rt2,int k)
{
	int id1=Root[rt1];
	int id2=Root[rt2];
	int L=1,R=n;
	while(L<R)
	{
		int mid=L+R>>1;
		int cnt=tree[Ls[id2]]-tree[Ls[id1]];//找第k小就看左邊 

		if(cnt>=k) 
		{
			R=mid;
			id1=Ls[id1];
			id2=Ls[id2];
		}
		else
		{
			k-=cnt;
			L=mid+1;
			id1=Rs[id1];
			id2=Rs[id2];
		}
	}
	return L;
}
int main()
{
	while(cin>>N>>Q)
	{
		
		Root.resize(1);
		tot=0;
		for(int i=1; i<=N; i++)
		{
			cin>>data[i];
			a[i]=data[i];
		}
		sort(a+1,a+1+N);
		n=unique(a+1,a+1+N)-(a+1);//離散化
		Root[0]=Build(1,n);
		for(int i=1; i<=N; i++)Update(Root[i-1],data[i]);
		for(int i=1; i<=Q; i++)
		{
			int L,R,K;
            cin>>L>>R>>K;
			int pos=query(L-1,R,K);
            cout<<a[pos]<<endl;
		}

	}
}

劃分樹：

/*
劃分樹 
*/
#include"iostream"
#include"algorithm"
using namespace std;
const int maxn=1e5+5;
int a[maxn];
int tree[30][maxn];
int num[30][maxn];
int N,M;
void print()
{
	int NN=1;
	while(NN<N)
	{
		NN<<=1;
		for(int i=1;i<=N;i++)cout<<tree[NN-1][i]<<" ";
		cout<<"\n";
	}
	cout<<"\n";
}
void Build(int dep,int L,int R)
{
	if(L==R)return ;
	int mid=(L+R)>>1;
	int same=mid-L+1;
	int ls=L,rs=mid+1;
	for(int i=L;i<=R;i++)if(tree[dep][i]>a[mid])same--;
	for(int i=L;i<=R;i++)
	{
		if(i==L)num[dep][i]=0;
		else num[dep][i]=num[dep][i-1];
		
		if(tree[dep][i]>a[mid])
		{
			num[dep][i]++;
			tree[dep+1][ls++]=tree[dep][i];
		}
		else if(tree[dep][i]==a[mid]&&same)
		{
			same--;
			num[dep][i]++;
			tree[dep+1][ls++]=tree[dep][i];
		}
		else tree[dep+1][rs++]=tree[dep][i];
	}
	Build(dep+1,L,mid);
	Build(dep+1,mid+1,R);
}
int Query(int dep,int ql,int qr,int L,int R,int K)
{
	if(L==R)return tree[dep][L];
	int mid=(L+R)>>1;
	int c1,c2;
	if(ql==L)
	{
		c1=0;
		c2=num[dep][qr];
	}
	else
	{
		c1=num[dep][ql-1];
		c2=num[dep][qr]-c1;
	}
	
	if(K<=c2)
	{
		ql=L+c1;
		qr=L+c1+c2-1;//這兒為什麼減1 啊？ 
		return Query(dep+1,ql,qr,L,mid,K);
	}
	else
	{
		ql+=mid-L+1 - c1;
		qr=mid-L+1 +qr-c1-c2;
		return Query(dep+1,ql,qr,mid+1,R,K-c2);
	}
}
int main()
{
	cin>>N;
	for(int i=1;i<=N;i++)
	{
		cin>>a[i];
		tree[0][i]=a[i];
	}
	sort(a+1,a+1+N,greater<int>());
	Build(0,1,N);
	cin>>M;
	for(int i=1;i<=M;i++)
	{
		int t1,t2,K;
		cin>>t1>>t2>>K;
		t1++;
		t2++;
		cout<<Query(0,t1,t2,1,N,K)<<"\n";
	}
}