acm数据结构整理

一、区间划分
//区间划分+持久化并查集：区间连通情况统计。
inline bool comp(Ask x, Ask y){return x.km == y.km ? x.l > y.l : x.km > y.km ; }
inline void init()//把编号相同的放一起，l从大到小；{
    int i ; 
    ms = sqrt(1.0*n) ; //大小
    mg = n/ms ; //块数
    mg = mg*ms == n ? mg : mg + 1 ; 
    for(i = 1 ; i <= n ; i ++) e[i].clear() ; 
}
/*********************持久化并查集**********************************/
void solve()//区间划分{
    int i = 1, j, k, l, r ;
    sort(ask+1, ask+1+q, comp) ; 
    while(i <= q) //询问
    {
        k = ask[i].km ;
        for(; i <= q && ask[i].km == k && ask[i].l > (k-1)*ms ; i ++) //处理区间小于ms的询问
            ans[ask[i].no] = bfAnswer(i) ; 
        if(i > q || ask[i].km != k ) //全部为小区间 
            continue ;
        r = (k-1)*ms ; //最右端
        initSet(lp, 1, r) ; //初始化并查集 ；
        for(j = 1 ; j <= r ; j ++) vis[j] = 0 ; 
        while(i <= q && ask[i].km == k ) //求解第k块的所有大询问；
        {
            l = ask[i].l ; 
            for(j = r ; j >= l ; j -- ) //加入顶点j
                addVex(lp, j, (k-1)*ms) ;
            r = j ; 
            for(; i <= q && ask[i].km == k && ask[i].l == l ; i ++) 
//计算所有左端等于l的区间；
            {
                ans[ask[i].no] = unionRSet(ask[i].no, l, (k-1)*ms+1, ask[i].r ) ; //右端暴力合并 ；
            }
        }
    }
}
二、2B树：动态区间比x小的数的个数。
void DT_insert(int rt, int x, int s ){
    int i = DN, j, p ;
    getBinary(x) ;
    j = dig[i--] ;
    if(root[rt].next[j] == -1) 
    {
        root[rt].next[j] = ++ tot ; 
        pool[tot].set() ;
    }
    if(!j) root[rt].sum += s ; 
    p = root[rt].next[j] ; 
    while(i)
    {
        j = dig[i--] ;
        if(pool[p].next[j] == -1) 
        {
            pool[p].next[j] = ++ tot ; 
            pool[tot].set() ;
        }
        if(!j)pool[p].sum += s ; 
        p = pool[p].next[j] ;
    }
}
int DT_count(int rt, int x){
    int i = DN, j, p, ans = 0 ;
    getBinary(x) ;
    j = dig[i--] ;
    if(j) ans += root[rt].sum ;
    if(root[rt].next[j] == -1) return ans ; 
    p = root[rt].next[j] ; 
    while(i)
    {
        j = dig[i--] ;
        if(j) ans += pool[p].sum ; 
        if(pool[p].next[j] == -1) return ans ;  
        p = pool[p].next[j] ;
    }
    return ans ; 
}
void DT_build(){
    int i, k ;
    size = sqrt(double(n)) ;
    mg = n/size ; 
    mg = mg*size == n ? mg : mg+1 ;  
    for(i = 1 ; i <= mg ; i ++) root[i].set() ; 
    for(i = 1 ; i <= n ; i ++)
    {
        k = (i-1)/size + 1 ; 
        DT_insert(k, ar[i], 1) ;
    }
    bs = 10*size ; 
    bmg = n/bs ; 
    bmg = bmg*bs == n ? bmg : bmg + 1 ; 
    for(i = 1 ; i <= bmg+1 ; i ++) root[MAXS+i].set() ; 
    for(i = 1 ; i <= n ; i ++)
    {
        k = (i-1)/bs + 1 ;
        DT_insert(MAXS+k, ar[i], 1) ; 
    }
}
int DT_query(int l, int r, int x){
    int i, k, ans = 0, bk ;
    k = (l-1)/size + 1 ;
    k = size*(k-1)+1 == l ? k : k + 1 ;  //前 
for(i = l ; i <= r && i < (k-1)*size+1 ; i ++) ans = ar[i] < x ? ans+1 : ans ;         
for(; i <= r && r-i+1 >= size && (k%10 != 1) ; i += size, k ++) //小块
        ans += DT_count(k, x) ;
for(bk = (k-1)/10+1 ; i <= r && r-i+1 >= bs ; i += bs, bk ++, k += 10)    
     ans += DT_count(MAXS+bk, x) ;//大块
    for(; i <= r && r-i+1 >= size ; i += size, k ++) //小块
        ans += DT_count(k, x) ;
    for(; i <= r ; i ++) ans = ar[i] < x ? ans+1 : ans ; 
    return ans ;
}
三、树链剖分
1. 树上区间[u, v] 异或 x 的最大值
// 持久化2B树 + 树链剖分（区间可直接合并）
inline void insert(int rt, int x) ； //建一颗空树
inline void addNumber(int pre, int &rt, int id, int x){//持久化
    int i = SD, p ;
    bool j ;
    rt = ++dcnt ; p = rt ;
    while(i >= 0 )
    {
        pool[p] = pool[pre] ;
        j = x&(1<<i) ;
        pool[p].mx[j] = id ;
        pool[p].next[j] = ++dcnt ;
        p = dcnt ;
        pre = pool[pre].next[j] ;
        i -- ;
    }
    pool[p].x = x ;
}
inline int DTcount(int rt,int l,int x)//计算前缀树[1,r]中下标>=l的与x的最大异或值
/*******c******************树链剖分*************************/
void DFS(int u){
    int i, to ;
    siz[u] = 1 ; son[u] = 0 ;
    for(i = head[u] ; i != -1 ; i = e[i].next )
    {
        to = e[i].to ;
        if(to != fa[u])
        {
            fa[to] = u ;
            dep[to] = dep[u] + 1 ;
            DFS(to) ;
            if(siz[son[u]] < siz[to]) son[u] = to ;
            siz[u] += siz[to] ;
        }
    }
}
void cutLink(int u, int tp){
    w[u] = ++cnt ;
    top[u] = tp ;
    if(son[u]) cutLink(son[u], tp) ;
    for(int i = head[u] ; i != -1 ; i = e[i].next)
    {
        int to = e[i].to ;
        if(to != fa[u] && to != son[u]) cutLink(to, to) ;
    }
}
void buildTree(){
    dep[1] = 1 ;
    cnt = fa[1] = siz[0] = 0 ;
    DFS(1) ;
    cutLink(1, 1) ;
    int i ;
    for(i = 1 ; i <= n ; i ++) val[w[i]] = ar[i] ;
    pool[0].set() ;
    dcnt = T[0] = 0 ;
    for(i = 1 ; i <= cnt ; i ++) insert(T[0], val[i]) ;
    for(i = 1 ; i <= cnt ; i ++) addNumber(T[i-1], T[i], i, val[i]) ;//持久化思
}
int getAns(int u, int v, int x){
    int ans = 0, tu = top[u], tv = top[v], tmp ;
    if(u == v) return DTcount(T[w[u]], w[v], x) ; ;
    while(tu != tv) //如果不在同一条链上
    {
        if(dep[tu] < dep[tv]) {swap(tu, tv) ; swap(u, v) ; }
        tmp = DTcount(T[w[u]], w[tu], x ) ; //查询从u到tu的父亲的最大值
        ans = max(ans, tmp) ;
        u = fa[tu] ;
        tu = top[u] ;
    }
    if(dep[u] < dep[v]) swap(u, v) ;
    tmp = DTcount(T[w[u]], w[v], x) ; 
    return max(ans, tmp) ;
}
2. BFS实现建树
int leaf[MAXN], ns[MAXN], ct[MAXN];
void BFS(int rt){
    int i, h = 0, t = 0, l = 0, r = 0 ;
    int u, to ;
    que[t++] = rt ;
    for(i = 1 ; i <= n ; i ++)
    {
        siz[i] = 1 ;
        ct[i] = ns[i] = son[i] = 0 ;
    }
    while (h < t) // calculate the dep.
    {
        u = que[h++] ;
        for(i = head[u] ; i != -1 ; i = e[i].next)
        {
            to = e[i].to ;
            if(to != fa[u])
            {
                ns[u] ++ ;
                fa[to] = u ;
                dep[to] = dep[u] + 1 ;
                que[t++] = to ;
            }
        }
    }
    for(i = 1 ; i <= n ; i ++) if(ns[i] == 0) leaf[r++] = i ;
    while(l < r)
    {
        to = leaf[l++] ;
        u = fa[to] ;
        siz[u] += siz[to] ; ct[u] ++ ;
        if(ct[u] == ns[u] && u ) leaf[r++] = u ;
    }
    h = t = 0 ;
    que[t++] = rt ;
    siz[0] = 0 ;
    while (h < t)
    {
        u = que[h++] ;
        for(i = head[u] ; i != -1 ; i = e[i].next)
        {
            to = e[i].to ;
            if(to != fa[u])
            {
                if(siz[son[u]] < siz[to]) son[u] = to ;
                que[t++] = to ;
            }
        }
    }
}
void BFS_cutLink(int rt, int tp){
    int i, u, to, h = 0, t = 0 ;
    que[t++] = rt ;
    while (h < t)
    {
        u = que[h++] ;
        w[u] = ++cnt ; top[u] = u ;
        to = son[u] ;
        while (to)
        {
            w[to] = ++cnt ; top[to] = u ;
            for(i = head[to] ; i != -1 ; i = e[i].next)
                if(e[i].to != fa[to] && e[i].to != son[to]) que[t ++] = e[i].to ;
            to = son[to] ;
        }
        for(i = head[u] ; i != -1 ; i = e[i].next)
        {
            to = e[i].to ;
            if(to != fa[u] && to != son[u]) que[t++] = to ;
        }
    }
}
3. 非直接合并查询：树上最长上升子序列
/*********************线段树成段更新最长上升子序列*************************/
void Up(int step){
L[step].lx = L[lson].lx + ( (L[lson].lx==L[lson].len && val[L[rson].left] > val[L[lson].right])?L[rson].lx:0) ;
    L[step].rx = L[rson].rx + ((L[rson].rx==L[rson].len &&val[L[rson].left] > val[L[lson].right])?L[lson].rx:0) ;
L[step].mx = max(max(L[lson].mx,L[rson].mx),val[L[rson].left]
 > val[L[lson].right]?(L[lson].rx+L[rson].lx):0);

   L[step].dlx = L[lson].dlx + ( (L[lson].dlx == L[lson].len && val[L[rson].left] < val[L[lson].right]) ? L[rson].dlx : 0 );
    L[step].drx = L[rson].drx + ((L[rson].drx == L[rson].len && val[L[rson].left] < val[L[lson].right]) ? L[lson].drx : 0 ) ;
L[step].dmx = max(max(L[lson].dmx,L[rson].dmx),val[L[rson].left]
 < val[L[lson].right] ? (L[lson].drx+L[rson].dlx) : 0 ) ;
}
void build(int step,int l,int r){
    L[step].left=l;
    L[step].right=r;
    L[step].len = r-l+1 ; 
    L[step].mid=(l+r)/2;
    if(l==r)
    {
        L[step].lx = L[step].rx = L[step].mx = 1 ;
        L[step].dlx =L[step].drx = L[step].dmx = 1 ;
        return ;
}
…… ；
}
inline void unionNode(int l, int r, int ar ){
L[ar].lx = L[l].lx + ((L[l].lx==L[l].len && val[L[r].left] 
> val[L[l].right]) ? L[r].lx : 0) ;
L[ar].rx = L[r].rx + ((L[r].rx==L[r].len && val[L[r].left] 
> val[L[l].right]) ? L[l].rx : 0) ;
L[ar].mx = max(max(L[l].mx,L[r].mx),val[L[r].left] 
> val[L[l].right]?(L[l].rx+L[r].lx):0);

L[ar].dlx = L[l].dlx + ((L[l].dlx == L[l].len && val[L[r].left]
< val[L[l].right]) ? L[r].dlx : 0 );
L[ar].drx = L[r].drx + ((L[r].drx == L[r].len && val[L[r].left] 
< val[L[l].right]) ? L[l].drx : 0 ) ;
L[ar].dmx = max(max(L[l].dmx,L[r].dmx),val[L[r].left] < val[L[l].right] 
? (L[l].drx+L[r].dlx) : 0 ) ;
    L[ar].left = L[l].left ;
    L[ar].right = L[r].right ; 
    L[ar].len = L[l].len + L[r].len ;
}
int query(int step,int l,int r){
    if(l==L[step].left&&r==L[step].right) return step ;
    …… ； 
    else    {
        int lt = query(lson,l,L[step].mid);
        int rt = query(rson,L[step].mid+1,r);
        ++scnt ;
        unionNode(lt, rt, scnt) ;
        return scnt ;
    }
}
/*************************树链剖分*************************/
inline int unionAns(int l, int r){
    int tmp = max(L[l].dmx, L[r].mx), ans ;
    if(val[L[l].left] < val[L[r].left]) ans = L[r].lx + L[l].dlx ;
    else ans = 0 ;
    ans = max(tmp, ans) ;
    return ans ;
}
int getAns(int u, int v){
    if(u == v) return L[query(1, w[u], w[u])].mx ;
    int tu = top[u], tv = top[v] ;
    int ar, tr, ur, vr ;
    scnt = 4*cnt +1;
    ar = ++scnt ; ur = -1 ; vr = -1 ;
    while (tu != tv)
    {
        if(dep[tu] > dep[tv])//calculate the link tu -> u.
        {
            tr = query(1, w[tu], w[u]) ;
            if(ur == -1) ur = tr ;
            else            {
                ++scnt ;
                unionNode(tr, ur, scnt); //tr is left node.
                ur = scnt ;
            }
            u = fa[tu] ; tu = top[u] ;
        }
        else        {
            tr = query(1, w[tv], w[v]) ;
            if(vr == -1) vr = tr ;
            else            {
                ++scnt ;
                unionNode(tr, vr, scnt) ; // tr is left node.
                vr = scnt ;
            }
            v = fa[tv] ; tv = top[v] ;
        }
    }
    if(dep[u] >= dep[v])// v is root.
    {
        tr = query(1, w[v], w[u]) ;
        if(ur == -1) ur = tr ;
        else        {
            scnt ++ ;
            unionNode(tr, ur, scnt) ;
            ur = scnt ;
        }
        u = v ;
    }
    else    {
        tr = query(1, w[u], w[v]) ;
        if(vr == -1) vr = tr ;
        else        {
            ++scnt ;
            unionNode(tr, vr, scnt) ;
            vr = scnt ;
        }
        v = u ;
    }
    if(ur == -1) return L[vr].mx ;
    else if(vr == -1) return L[ur].dmx ;
    return unionAns(ur, vr) ; // calculate the answer of u->v
}
4. 树上最大字段和
/*********************线段树最大子段和*************************/
inline void Up(int rt){
    sum[rt] = sum[rt<<1] + sum[rt<<1|1] ;
    lx[rt] = max(lx[rt<<1|1], lx[rt<<1] + sum[rt<<1|1]) ;
    rx[rt] = max(rx[rt<<1], rx[rt<<1|1] + sum[rt<<1]) ;
    mx[rt] = max(mx[rt<<1], mx[rt<<1|1]) ;//不合并
    mx[rt] = max(mx[rt], lx[rt<<1] + rx[rt<<1|1]) ; //合并
}
inline void Down(int rt, int L, int R){
    if(d[rt] != INF)
    {
        int x = d[rt] ;
        int mid = (L+R) >> 1 ;
        d[rt] = INF ;
        d[rt<<1] = d[rt<<1|1] = x ;
        sum[rt<<1] = (LL)x*(mid-L+1) ;
        sum[rt<<1|1] = (LL)x*(R-mid) ;
        lx[rt<<1] = rx[rt<<1] = mx[rt<<1] = x > 0 ? sum[rt<<1] : 0 ;
        lx[rt<<1|1] = rx[rt<<1|1] = mx[rt<<1|1] = x > 0 ? sum[rt<<1|1] : 0 ;
    }
}
inline void unionNode(int l, int r, int ar ){
    sum[ar] = sum[l] + sum[r] ;
    lx[ar] = max(lx[r], lx[l]+sum[r]) ;
    rx[ar] = max(rx[l], rx[r]+sum[l]) ;
    mx[ar] = max(mx[l], mx[r]) ;
    mx[ar] = max(mx[ar], lx[l]+rx[r]) ;
}
void build(int rt, int l, int r){
    d[rt] = INF ;
    if(l == r)
    {
        sum[rt] = lx[rt] = rx[rt] = mx[rt] = val[l] ;
        return ;
}
…… ；
}
void updata(int rt, int L, int R, int l, int r, int x){
    if(L == l && r == R)
    {
        sum[rt] = (R-L+1)*x ;
        lx[rt] = rx[rt] = mx[rt] = x > 0 ? sum[rt] : 0 ;
        d[rt] = x ;
        return ;
    }
Down(rt, L, R) ;
…… ； 
}
int query(int rt, int L, int R, int l, int r){
    if(L == l && R == r) return rt ;
    Down(rt, L, R) ;
    …… ； 
    else    {
        int x = query(rt<<1, L, mid, l, mid) ;
        int y = query(rt<<1|1, mid+1, R, mid+1, r) ;
        ++scnt ;
        unionNode(x, y, scnt) ;
        return scnt ;
    }
}
/*************************树链剖分*************************/
inline void unionAns(int x, int y, int ar){
    mx[ar] = max(mx[x], mx[y]) ;
    mx[ar] = max(mx[ar], rx[x]+rx[y]) ;
}
int getAns(int u, int v){
    if(u == v) return query(1, 1, cnt, w[u], w[u]) ;
    int tu = top[u], tv = top[v] ;
    int ar, tr, ur, vr ;
    scnt = 4*cnt +1;
    ar = ++scnt ; ur = -1 ; vr = -1 ;
    while (tu != tv)
    {
        if(dep[tu] > dep[tv])//calculate the link tu -> u.
        {
            tr = query(1, 1, cnt, w[tu], w[u]) ;
            if(ur == -1) ur = tr ;
            else            {
                ++scnt ;
                unionNode(tr, ur, scnt); //tr is left node.
                ur = scnt ;
            }
            u = fa[tu] ; tu = top[u] ;
        }
        else        {
            tr = query(1, 1, cnt, w[tv], w[v]) ;
            if(vr == -1) vr = tr ;
            else            {
                ++scnt ;
                unionNode(tr, vr, scnt) ; // tr is left node.
                vr = scnt ;
            }
            v = fa[tv] ; tv = top[v] ;
        }
    }
    if(dep[u] >= dep[v])
    {
        tr = query(1, 1, cnt, w[v], w[u]) ;
        if(ur == -1) ur = tr ;
        else        {
            scnt ++ ;
            unionNode(tr, ur, scnt) ;
            ur = scnt ;
        }
        u = v ;
    }
    else    {
        tr = query(1, 1, cnt, w[u], w[v]) ;
        if(vr == -1) vr = tr ;
        else        {
            ++scnt ;
            unionNode(tr, vr, scnt) ;
            vr = scnt ;
        }
        v = u ;
    }
    if(ur == -1) return vr ;
    else if(vr == -1) return ur ;
    unionAns(ur, vr, ar) ; // calculate the answer of u->v
    return ar ;
}
四、持久化线段树
/*******************静态 Kth number ***************************************/
void build(int &rt, int l, int r ){
    rt = ++tot ;
    sum[rt] = 0 ; 
if(l >= r) return ;
…… ； 
}
void updata(int &rt, int pre, int l, int r, int i, int v){
    rt = ++tot ;
    ls[rt] = ls[pre] ; rs[rt] = rs[pre] ; sum[rt] = sum[pre] + v ; 
    if(l >= r ) return ; 
    int mid = l+r >> 1 ;
    if(mid >= i ) updata(ls[rt], ls[pre], l, mid, i, v) ; 
    else updata(rs[rt], rs[pre], mid+1, r, i, v) ;
}
int query(int R, int L, int l, int r, int k){
    if(l >= r) return l ; 
    int t = sum[ls[R]] - sum[ls[L]] ;
    int mid = l+r >> 1 ; 
    if(t >= k) return query(ls[R], ls[L], l, mid, k) ;
    else return query(rs[R], rs[L], mid+1, r, k-t) ; 
}
/***************************************************************/
void solve(){ 
     sort(ord+1, ord+1+n, comp) ;
     cnt = rk[ord[1]] = 1 ; 
     nar[cnt] = ar[ord[1]] ; 
     for(i = 2 ; i <= n ; i ++)
     {
          if(ar[ord[i]] != ar[ord[i-1]])
          {
              rk[ord[i]] = ++cnt ;
              nar[cnt] = ar[ord[i]] ; 
          }
          else rk[ord[i]] = cnt ;
      }
      tot = 0 ; 
      build(T[0], 1, cnt) ; 
      for(i = 1 ; i <= n ; i ++) updata(T[i], T[i-1], 1, cnt, rk[i], 1) ;
      for(i = 1 ; i <= m ; i ++)
      {
          scanf("%d %d %d", &l, &r, &k) ;
          ans = query(T[r], T[l-1], 1, cnt, k) ;
          printf("%d
", nar[ans]) ;//离散后的数组
      }
    }
  }
五、KD树
#define N 50005
#define MID(x,y) ( (x + y)>>1 )
using namespace std ;
typedef long long LL ;
struct Point{
    int x[5];
    LL dis;
    Point(){
        for(int i = 0 ; i < 5 ; i++) x[i] = 0 ;
        dis = 9223372036854775807LL ;
    }
friend bool operator < (const Point &a, const Point &b) 
{ return a.dis < b.dis ; }
};
priority_queue <Point, vector<Point> > res ;
LL dist2(const Point &a, const Point &b, int k) {           
//距离的*方,开根号很耗时，能不开就不开
    LL ans = 0;
for (int i = 0; i < k; i++)         
//一开始这儿写的i < 5，WA了N次。。。原本以为只要初始值设0就无所谓,
        ans += (a.x[i] - b.x[i]) * (a.x[i] - b.x[i]);  
   //但发现Point有个全局变量，在多case下会出错。。。
    return ans;
}
int ddiv;
bool cmpX(const Point &a, const Point &b){return a.x[ddiv] < b.x[ddiv];}
struct KDTree   {
    Point p[N];        //空间内的点
int Div[N];        
//记录区间是按什么方式划分（分割线*行于x轴还是y轴, ==1*行y轴切;==0*行x轴切）
    int k;          //维数
    int m;          //*邻
int getDiv(int l, int r)   {     //寻找区间跨度最大的划分方式
        map <int, int> ms;
        int minx[5],maxx[5];
        for (int i = 0; i < k; i++)
        {
            ddiv = i;
            minx[i] = min_element(p + l, p + r + 1, cmpX)->x[i];
            maxx[i] = max_element(p + l, p + r + 1, cmpX)->x[i];
            ms[maxx[i] - minx[i]] = i;
        }
        map <int ,int>::iterator pm = ms.end();
        pm--;
        return pm->second;
    }
    void build(int l, int r)  {      //记得先把p备份一下。
        if (l > r)    return;
        int mid = MID(l,r);
        Div[mid] = getDiv(l,r);
        ddiv = Div[mid];
        nth_element(p + l, p + mid, p + r + 1, cmpX);
        build(l, mid - 1);
        build(mid + 1, r);
    }
    void findk(int l, int r, Point a) {//k(m)*邻，查找k*点的*方距离
        if (l > r)    return;
        int mid = MID(l,r);
        LL dist = dist2(a, p[mid], k);
        if (dist >= 0)
        {
            p[mid].dis = dist;
            res.push(p[mid]);
            while ((int)res.size() > m)
                res.pop();
        }
        LL d = a.x[Div[mid]] - p[mid].x[Div[mid]];
        int l1, l2, r1, r2;
        l1 = l , l2 = mid + 1;
        r1 = mid - 1, r2 = r;
        if (d > 0)
            swap(l1, l2), swap(r1, r2);
        findk(l1, r1, a);
        if ((int)res.size() < m || d*d < res.top().dis )
            findk(l2, r2, a);
    }
};
Point pp[N];
KDTree kd;
int solve(){
       for (int i = 0; i < n; i++)
            for (int j = 0; j < kd.k; j++)
            {
                scanf("%d", &pp[i].x[j]);
                kd.p[i] = pp[i];
            }
        kd.build(0, n - 1);
        int t = 10 ;
        while(t--)
        {
            Point a;
            for (int i = 0; i < kd.k; i++)scanf("%d", &a.x[i]);
            scanf("%d", &kd.m);
            kd.findk(0, n - 1, a);
            printf("the closest %d points are:
", kd.m);
            Point ans[11];
            for (int i = 0; !res.empty(); i++)
            {
                ans[i] = res.top();
                res.pop();
            }
            for (int i = kd.m - 1; i >= 0; i--)
            {
                for (int j = 0; j < kd.k - 1; j++)
                    printf("%d ", ans[i].x[j]);
                printf("%d
", ans[i].x[kd.k - 1]);
            }
        }  
六、最远manhattan距离
int query(int rt, int p, int s) //维护每个状态的最大值、最小值。
void getTable(int pos){//每个点有sta个状态
    int i, j, t ;
    for(i = 0 ; i < sta ; i ++)
    {
        t = i ;
        tmp[i] = 0 ; 
        for(j = 1 ; j <= k ; j ++)
        {
            if(t&1) tmp[i] += ar[pos].x[j] ; 
            else tmp[i] -= ar[pos].x[j] ;
            t >>= 1 ; 
        }
    }
}
int solve(){
        sta = 1<<k ; //K维*面 
        build(1, 1, q) ;//将每个点的sta个状态插入树中
        cnt = 0 ; 
        for(i = 1 ; i <= q ; i ++)
        {
            if(cnt < 2){puts("0") ;continue ; }
            int ans = 0 ; 
            for(j = 0 ; j < sta ; j ++)
            {    
                mxs = query(1, j, 1) ; //查询最大值；
                mns = query(1, j, 0) ; //查询最小值；
                ans = ans > mxs - mns ? ans : mxs-mns ; 
            }
            printf("%d
", ans) ; 
        }
七、LCA & RMQ & 树状数组
/*****************************LCA*******************************/
struct QNode{
    int from, to, next, no ;
}qe[MAXN];
int cnt ; 
int qhead[MAXN], pre[MAXN], LCA[MAXN] ;
inline void addQEdge(int a,int b,int c){
    qe[++cnt].from = a ;
    qe[cnt].to = b ;
    qe[cnt].next = qhead[a] ;
    qe[cnt].no = c ;
    qhead[a] = cnt;
}
int find(int x){
    if(x != pre[x]) pre[x]=find(pre[x]);
    return pre[x];
}
void tarjan(int u){
    int j, v ;
    pre[u] = u ;
    for(j = qhead[u] ; j != -1 ; j = qe[j].next)
    {
        v = qe[j].to; 
        LCA[qe[j].no] = find(v) ;
    }
    for(j = head[u] ; j != -1 ;j = e[j].next)
    {
        v = e[j].to ;
        tarjan(v) ;
        pre[v] = u ;
    }
}
/*****************************RMQ*******************************/
int mn[MAXN][18] ;
void rmq_init(int num){
    int i , j ;
    for(j = 1 ; j <= num ; j ++ ) mn[j][0] = height[j] ;
    int m = floor(log((double)num)/log(2.0)) ;
    for(i = 1 ; i <= m ; i ++ )
    {
        for(j = num ; j > 0 ; j -- )
        {
            mn[j][i] = mn[j][i-1] ;
            if(j+(1<<(i-1)) <= num)
 mn[j][i] = min( mn[j][i] , mn[j+(1<<(i-1))][i-1]) ;
        }
    }
}
int rmq(int l,int r){
    int m = floor(log((double)(r-l+1))/log(2.0)) ;
    int a = min(mn[l][m], mn[r-(1<<m)+1][m] ) ;
    return a ;  
}
/*****************************树状数组*******************************/
int Lowbit(int t){ //求最小幂2^k
    return t&(-t) ; 
} 
int Sum(int end) { //求前n项和
    int sum = 0 ; 
    while(end > 0) 
    { 
        sum += c[end]; 
        end -= Lowbit(end); 
    } 
    return sum; 
} 
void plus(int pos , int n, int num){ //对某个元素进行加法操作
    while(pos <= n) 
    { 
        c[pos] += num; 
        pos += Lowbit(pos); 
    } 
}
八、划分树
int SU[100001];
int U[21][100001];
int toL[21][100001];
int n,m,a,b,k,t;
inline int cmp(const void *a,const void *b){return *((int *)a) - *((int *)b) ;}
void buildtree(int l,int r,int d){
    int i ;
    if (l==r) return;
    int mid = (l+r)>>1 , nowl = l , nowr = mid+1 , midtol = 0 ;
    for (i = mid ;i>=l  &&   SU[i] == SU[mid] ; i--) ++midtol ;
    for (i = l ; i <= r ; i++)
    {
        toL[d][i] = i==l ? 0 : toL[d][i-1];
        if (U[d][i] < SU[mid])
        {
            U[d+1][nowl++] = U[d][i];
            ++toL[d][i];
        }
        else if (U[d][i]==SU[mid] && midtol)
        {
            U[d+1][nowl++] = U[d][i];
            ++toL[d][i];
            --midtol;
        }
        else U[d+1][nowr++] = U[d][i];
    }
    buildtree(l,mid,d+1);
    buildtree(mid+1,r,d+1);
}
int answer(int a,int b,int k){
    int l = 1,r = n,d = 0;
    int ls,rs,mid;
    while (a != b)
    {
        ls = a==l ? 0 : toL[d][a-1];
        rs = toL[d][b];
        mid = (l+r)>>1;
        if (k <= rs - ls)
        {
            a = l+ls;
            b = l+rs-1;
            r = mid;
        }
        else        {
            a = mid+1+a-l-ls;
            b = mid+1+b-l-rs;
            k -= rs-ls;
            l = mid+1;
        }
        ++d;
    }
    return U[d][a];
}
int solve(){
        for (i=1;i<=n;i++)
        {
            scanf("%d",&t);
            SU[i]=U[0][i]=t;
        }
        sort(SU+1, SU+1+n) ;
        buildtree(1 , n , 0 );
            printf("%d
",answer(a, b, k ) );
    }