hdu 2665 Kth number （函数式线段树）+ SPOJ Count on a tree

划分树解法可以参考：  http://blog.csdn.net/freezuoguan/article/details/8490643

链接： http://acm.hdu.edu.cn/showproblem.php?pid=2665

题意：求区间第K大的数：

朴素的想法是：首先离散化数列，对于数列的所有前缀都建立一棵线段树，以b[i]为根， 线段树[ l, r ] 存的是符合 l  <= a[j] <= r ( 1 <= j <= i )的个数( 记为sum[b']， b'是b[i]的子树或者本身）， 注意a[j]是经过离散化的。然后每一次询问 [ u, v ]之间的第k大的数可以这样求: 用第 v 棵线段树 减去 第 u - 1 的sum值就可以知道第k大的数是在树的左儿子还是右儿子了。

可是建 n 棵线段树在时间和空间上开销都太大了，所以函数式线段树就来了 仔细想想第 i 棵线段树和第i-1棵线段树的关联，b[i-1]的线段树加上一个a[i]就是b[i]的线段树了，所以，b[i]每一层的左右儿子中有且仅有一个儿子是和b[i-1]每一层对应的儿子是一样的，所以b[i]只需要新建 log(n)个儿子就好了。

:第一个是划分树，第二个是函数式线段树，个人感觉函数式比较好打，但是一开始很难理解，因为和普通线段树的差挺多的

#include <iostream>
#include <cstdio>
#include <vector>
#include <list>
#include <set>
#include <stack>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <cstring>

using namespace std;
#define inf 1000000007
#define M 100007
#define N 111
#define ll long long
#define mod 1000000007
#define eps 1e-8

//丫的第一个函数线段树

int L[M<<5], R[M<<5], sum[M<<5];
int tail;
int a[M], b[M], lisan[M], cnt;
void build( int l, int r, int &p )
{
    p = ++tail; sum[p] = 0;
    if( l >= r ) return;
    int m = l + r >> 1;
    build( l, m, L[p] );
    build( m+1, r, R[p] );
}

void update( int pre, int &p, int l, int r, int x )
{
    p = ++tail;
    L[p] = L[pre], R[p] = R[pre], sum[p] = sum[pre] + 1;
    if( l >= r ) return;
    int m = l + r >> 1;
    if( x <= m ) update( L[pre], L[p], l, m, x );
    else update( R[pre], R[p], m+1, r, x );
}

int query( int u, int v, int l, int r, int k )
{
    if( l >= r ) return l;
    int m = l + r >> 1;
    int num = sum[L[v]] - sum[L[u]];
    if( num >= k ) return query( L[u], L[v], l, m, k );
    else return query( R[u], R[v], m+1, r, k - num );
}
int main()
{
    //freopen( "a.in", "r", stdin );
    int T, n, m, x, l, r, k;
    scanf( "%d", &T );
    while( T-- ){
        scanf( "%d%d", &n, &m );
        tail = 0;
        for( int i = 1; i <= n; ++i ){
            scanf( "%d", a+i );
            lisan[i] = a[i];
        }
        sort( lisan + 1, lisan + n + 1 );
        cnt = unique( lisan + 1, lisan + n + 1 ) - lisan - 1;

        build( 1, cnt, b[0] );
        for( int i = 1; i <= n; ++i ){
            x = lower_bound( lisan+1, lisan + cnt + 1, a[i] ) - lisan;
            update( b[i-1], b[i], 1, cnt, x );
        }
        for( int i = 0; i < m; ++i ){
            scanf( "%d%d%d", &l, &r, &k );
            x = query( b[l-1], b[r], 1, cnt, k );
            printf( "%d\n", lisan[x] );
        }
    }
}

SPOJ Count on a tree ：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=27637

原理一样，就是在深搜过程中更新节点，并且求最近公共祖先。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<stack>
#include<string>
#include<map>
#include<cmath>
#include<vector>
using namespace std;
#define M 100007

int a[M], lisan[M], cnt;
int root[M*30], L[M*30], R[M*30], sum[M*30], tail;
int vv[M<<1], nxt[M<<1], h[M], e;
int pre[M], fa[M], lca[M], vis[M];
int x[M], y[M], k[M];
vector< pair<int, int> > V[M];

void build( int l, int r, int &p )
{
    p = ++tail;
    sum[p] = 0;
    if( l >= r ) return;
    int m = l + r >> 1;
    build( l, m, L[p] );
    build( m+1, r, R[p] );
}

void add( int u, int fa, int x )
{
    int p = root[u] = ++tail;
    int l = 1, r = cnt;
    while( l <= r ){
        L[p] = L[fa], R[p] = R[fa], sum[p] = sum[fa] + 1;
        if( l == r ) break;
        int m = l + r >> 1;
        if( x <= m ){
            L[p] = ++tail; r = m; fa = L[fa]; p = tail;
        }
        else{
            R[p] = ++tail; l = m+1; fa = R[fa]; p = tail;
        }
    }
}

int find( int u )
{
    if( u == fa[u] ) return u;
    return fa[u] = find( fa[u] );
}
void dfs( int u, int ff )
{
    pre[u] = ff;
    add( u, root[ff], a[u] );
    for( int i = h[u]; i+1; i = nxt[i] ){
        int v = vv[i]; if( v == ff ) continue;
        dfs( v, u );
        fa[v] = u;
    }
    vis[u] = 1;
    int len = V[u].size();
    for( int i = 0; i < len; ++i ){
        int v = V[u][i].first;
        if( vis[v] ) lca[V[u][i].second] = find( v );
    }
}

int query( int u, int v, int fa, int ff, int l, int r, int k )
{
    if( l >= r ) return l;
    int s = sum[L[u]] + sum[L[v]] - sum[L[fa]] - sum[L[ff]];
    int m = l + r >> 1;
    if( s >= k ){
        return query( L[u], L[v], L[fa], L[ff], l, m, k );
    }
    else return query( R[u], R[v], R[fa], R[ff], m+1, r, k - s );
}
int main()
{
    int n, m, u, v;
    while( scanf( "%d%d", &n, &m ) == 2 ){
        for( int i = 1; i <= n; ++i ){
            scanf( "%d", &u );
            lisan[i] = a[i] = u;
        }
        sort( lisan + 1, lisan + n + 1 );
        cnt = unique( lisan+1, lisan+n+1 ) - lisan - 1;
        for( int i = 1; i <= n; ++i ) a[i] = lower_bound( lisan+1, lisan+cnt+1, a[i] ) - lisan;
        tail = 0;
        build( 1, cnt, root[0] );
        for( int i = 1; i <= n; ++i ) V[i].clear();
        memset( h, -1, sizeof(h) ); e = 0;
        for( int i = 1; i < n; ++i ){
            scanf( "%d%d", &u, &v );
            vv[e] = v; nxt[e] = h[u]; h[u] = e++;
            vv[e] = u; nxt[e] = h[v]; h[v] = e++;
        }
        for( int i = 0; i < m; ++i ){
            scanf( "%d%d%d", x+i, y+i, k+i );
            V[x[i]].push_back( make_pair( y[i], i ) );
            V[y[i]].push_back( make_pair( x[i], i ) );
        }
        for( int i = 0; i <= n; ++i ) fa[i] = i;
        memset( vis, 0, sizeof(vis) );
        dfs( 1, 0 );
        for( int i = 0; i < m; ++i ){
            int ans = query( root[x[i]], root[y[i]], root[lca[i]], root[pre[lca[i]]], 1, cnt, k[i] );
            printf( "%d\n", lisan[ans] );
        }
    }
}