题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1146
极端恶心的一道模版题。
解法一：
这道题很容易就可以联想到主席树，但是主席树维护的是序列，那么就直接做成DFS序列，每个点拆成一个进点(in[v])和出点(out[v]),然后对于每个进点+w[i],每个出点-w[i],又要支持修改，那么就树状数组套主席树，然后直接在主席树上二分，时空复杂度均为O(n log^2 n)，然后我就很兴奋地敲了200+代码，结果一交上去果断MLE，然后才发现自己写的主席树占用空间都差不多500M了，果断放弃。（ORZ此法过的大神）
解法二：
树链剖分+树状数组（线段树）+平衡树+二分查找，复杂度：O(q log^4 n)，相当高的复杂度。
解法三：
树链剖分+树状数组（线段树）+主席树，复杂度O(q log^3 n),还算好写，不过我死活空间省不到161M。
解法四：
DFS序+树状数组+平衡树+二分查找，在解法一的基础上把主席树改成BST，然后二分答案，复杂度O(n log^2 n + q log^3 n),个人觉得相当好写。
代码（dfs序+BIT套SBT+二分查找，苦逼的300+行，还慢得要死）：
fcfaaf51f3deb48f59752fd3f21f3a292df5789b.jpg.png
#include
#include
#include
#include
using namespace std;
#define MAXN 80010
#define MAXV 4000010
#define inf 0x7fffffff
#define lowbit(x)((-x)&x)
#define L(t) Node[t].left
#define R(t) Node[t].right
#define K(t) Node[t].key
#define S(t) Node[t].size
#define update(t) S(t)=S(L(t))+S(R(t))+1
int w[MAXN],n,m,Query[MAXN][3];
//---------------------------------Size_Balanced_Tree_Start------------------------
struct node {
int left,right,key,size;
node () {
left=right=key=size=0;
}
} Node[MAXV];
queueQ;
int V=0;
void init_sbt() {
L(0)=R(0)=S(0)=0;
while (!Q.empty()) Q.pop();
}
int New() {
if (!Q.empty()) {
int v=Q.front();
Q.pop();
L(v)=R(v)=0;
return v;
}
return ++V;
}
void Recycle(int t) {
Q.push(t);
}
void left_ratote(int &t) {
int k=R(t);
R(t)=L(k); update(t);
L(k)=t; update(k);
t=k;
}
void right_ratote(int &t) {
int k=L(t);
L(t)=R(k); update(t);
R(k)=t; update(k);
t=k;
}
void maintain(int &t) {
if (S(L(L(t)))>S(R(t))) {
right_ratote(t);
maintain(R(t));
maintain(t);
return ;
}
if (S(R(L(t)))>S(R(t))) {
left_ratote(L(t));
right_ratote(t);
maintain(L(t)),maintain(R(t));
maintain(t);
return ;
}
if (S(R(R(t)))>S(L(t))) {
left_ratote(t);
maintain(L(t));
maintain(t);
return ;
}
if (S(L(R(t)))>S(L(t))) {
right_ratote(R(t));
left_ratote(t);
maintain(L(t)),maintain(R(t));
maintain(t);
return ;
}
}
void Insert(int k,int &t) {
if (!t) {
t=New();
S(t)=1,K(t)=k;
return ;
}
S(t)++;
if (kt=t,p->next=head[s];
head[s]=p;
}
void AddEdge(int s,int t) {
Add(s,t),Add(t,s);
}
int In[MAXN],Out[MAXN],Index=0;
bool f[MAXN];
void dfs(int v) {
In[v]=++Index,f[v]=false;
for (edge *p=head[v];p;p=p->next) if (f[p->t]) dfs(p->t);
Out[v]=++Index;
}
//-------------------------------Tree_End------------------------------------------
//-------------------------Binary_Index_Tree_Start---------------------------------
int bit[MAXN*2][2];
void bit_insert(int x,int y,int t) {
for (;x<=2*n;x+=lowbit(x)) Insert(y,bit[x][t]);
}
void bit_delete(int x,int y,int t) {
for (;x<=2*n;x+=lowbit(x)) Delete(y,bit[x][t]);
}
void bit_init() {
memset(bit,0,sizeof(bit));
for (int i=0;i++y;
}
void Sort() {
sort(c+1,c+Nn+1,cmp);
for (int i=0;i++next=fro[s],p->t=t,p->r=r;
fro[s]=p;
}
int father[MAXN],lca[MAXN];
int Find(int x) {
int i=x,j=x;
for (;father[i];i=father[i]) ;
while (father[j]) {
int k=father[j];
father[j]=i;
j=k;
}
return i;
}
void Tarjan(int v) {
f[v]=false;
for (saver *p=fro[v];p;p=p->next) if (!f[p->t]) lca[p->r]=Find(p->t);
for (edge *p=head[v];p;p=p->next) if (f[p->t]) {
Tarjan(p->t);
father[Find(p->t)]=v;
}
}
void Tarjan_lca() {
memset(fro,0,sizeof(fro));
memset(father,0,sizeof(father));
memset(f,true,sizeof(f));
for (int i=0;i++k?1:0);
}
int main() {
scanf("%d%d",&n,&m);
c[++Nn]=-inf,c[++Nn]=inf;
for (int i=0;i++1) {
int mid=(l+r)>>1;
int sum=rank_path(Query[i][1],Query[i][2],lca[i],b[mid]);
if (sum>=Query[i][0]) r=mid; else l=mid;
}
printf("%d\n",b[l]);
}
}
}
return 0;
}