hdu 4718 The LCIS on the Tree

求树上的最长上升子串

树链剖分+线段树，代码比较长。还有个做法是动态树，下次再看看

#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <cstdio>
using namespace std;
const int N = 1e5+5;
struct EG
{
    int v, next;
} eg[N];
int cnt;
int head[N];
void add_eg(int u,int v)
{
    ++cnt;
    eg[cnt].next = head[u]; eg[cnt].v = v; head[u] = cnt;
}
int fa[N], dep[N], sz[N], son[N];
int top[N];
int val[N], val_2[N];
int w[N];
int n_id;
void dfs_1(int id)
{
    son[id] = -1;
    sz[id] = 1;
    for(int i=head[id]; ~i; i=eg[i].next){
        int v = eg[i].v;
        dep[v] = dep[id]+1;
        fa[v] = id;
        dfs_1(v);
        if(son[id] == -1 || sz[son[id]] < sz[v]) son[id] = v;
        sz[id] += sz[v];
    }
}
void build_1(int id,int tp)
{
    top[id] = tp;
    w[id] = ++n_id;
    if(son[id] != -1) build_1(son[id], tp);
    for(int i=head[id]; ~i; i=eg[i].next){
        int v = eg[i].v;
        if(v != son[id]) build_1(v, v);
    }
}
void init()
{
    memset(head, -1, sizeof(head));
}
struct DT
{
    int l, r;
    int u_l, u_r, u_max;
    int d_l, d_r, d_max;
    int len;
} dt[N<<2];
DT merge_dt(DT x,DT y)
{
    DT tmp;
    tmp.l = x.l, tmp.r = y.r;
    tmp.len = x.len + y.len;


    tmp.d_max = max(x.d_max, y.d_max);
    tmp.d_l = x.d_l; tmp.d_r = y.d_r;
    if(val_2[x.r] > val_2[y.l]){
        if(x.d_l == x.len){
            tmp.d_l = x.d_l+y.d_l;
            tmp.d_max = max(tmp.d_max, tmp.d_l);
        }
        if(y.d_r == y.len){
            tmp.d_r = y.d_r+x.d_r;
            tmp.d_max = max(tmp.d_max, tmp.d_r);
        }
        tmp.d_max = max(tmp.d_max, x.d_r+y.d_l);
    }

    tmp.u_max = max(x.u_max, y.u_max);
    tmp.u_l = x.u_l; tmp.u_r = y.u_r;
    if(val_2[x.r] < val_2[y.l]){
        if(x.u_l == x.len){
            tmp.u_l = x.u_l+y.u_l;
            tmp.u_max = max(tmp.u_max, tmp.u_l);
        }
        if(y.u_r == y.len){
            tmp.u_r = y.u_r+x.u_r;
            tmp.u_max = max(tmp.u_max, tmp.u_r);
        }
        tmp.u_max = max(tmp.u_max, x.u_r+y.u_l);
    }
    return tmp;
}

void build(int l,int r,int rt)
{
    if(l == r){
        DT &tmp = dt[rt];
        tmp.d_l = tmp.d_r = tmp.d_max = tmp.u_l = tmp.u_r = tmp.u_max = tmp.len = 1;
        tmp.l = l; tmp.r = r;
        return;
    }
    int mid = (l+r)>>1;
    build(l, mid, rt<<1);
    build(mid+1, r, rt<<1|1);
    dt[rt] = merge_dt(dt[rt<<1], dt[rt<<1|1]);
}
DT query(int l,int r,int rt)
{
    if(l <= dt[rt].l && dt[rt].r <= r){
        return dt[rt];
    }
    int mid = (dt[rt].l + dt[rt].r) >> 1;
    if(r <= mid) return query(l, r, rt<<1);
    else if(l > mid) return query(l, r, rt<<1|1);
    else return merge_dt(query(l, r, rt<<1), query(l, r, rt<<1|1));
}
int deal(int x,int y)
{
    bool dir = 1;
    int f1, f2;
    DT ans1, ans2;
    bool st1, st2;
    st1 = st2 = false;
    f1 = top[x], f2 = top[y];
    while(f1 != f2){
        if(dep[f1] > dep[f2]){
            if(st1){
                ans1 = merge_dt(query(w[f1], w[x], 1), ans1);
            }else{
                ans1 = query(w[f1], w[x], 1);
                st1 = true;
            }
            x = fa[f1];
            f1 = top[x];
        }else{
            if(st2){
                ans2 = merge_dt(query(w[f2], w[y], 1), ans2);
            }else{
                ans2 = query(w[f2], w[y], 1);
                st2 = true;
            }
            y = fa[f2];
            f2 = top[y];
        }
    }
    if(dep[x] < dep[y]){
        if(st2){
            ans2 = merge_dt(query(w[x], w[y], 1), ans2);
        }else{
            ans2 = query(w[x], w[y], 1);
            st2 = true;
        }
    }else{
        if(st1){
            ans1 = merge_dt(query(w[y], w[x], 1), ans1);
        }else{
            ans1 = query(w[y], w[x], 1);
            st1 = true;
        }
    }
    int ret = 0;
    if(st1 && st2){
        ret = max(ans1.d_max, ans2.u_max);
        if(val_2[ans1.l] < val_2[ans2.l]){
            ret = max(ret, ans1.d_l+ans2.u_l);
        }
    }else if(st1){
        ret = ans1.d_max;
    }else if(st2){
        ret = ans2.u_max;
    }
    return ret;
}
int main()
{
    int i, j, n;
    int p;
    int T;
    int go = 0;
    scanf("%d",&T);
    while(T--){
        if(go) puts("");
        scanf("%d",&n);
        init();
        for(i=1; i<=n; ++i) scanf("%d",&val[i]);
        cnt = 0;
        for(i=2; i<=n; ++i){
            scanf("%d",&p);
            add_eg(p, i);
        }
        n_id = 0;
        dfs_1(1);
        build_1(1, 1);
        for(i=1; i<=n; ++i){
            val_2[w[i]] = val[i];
        }
        build(1, n, 1);
        int Q;
        scanf("%d",&Q);
        int u, v;
        printf("Case #%d:\n",++go);
        while(Q--){
            scanf("%d%d",&u,&v);
            printf("%d\n",deal(u, v));
        }
    }
    return 0;
}