城市网络——可持久化栈

思路

• 我们发现对于树上$[l,r]$的路径一定是包含在从根节点出发的某条链中的。
• 而$DFS$的过程中恰好便利了所有的这样的链于是我们可以用一个单调栈来维护有关链的答案。
• 有了单调栈以后我们可以通过二分以$o(log_n)$的复杂度来求解了。
• 可是此时我们发现$DFS$的过程中每次我们加入新的节点之后单调栈就发生了变化，在添加下一个节点的时候就不可用了。举一个简单的例子
  
  
• 可此时我们发现每次加入一个新的节点时，尽管它需要弹掉很多的元素，但实际上我们只需要找到它要替换掉的下标即可。此后再暂时改变它的长度。最后在要离开这个节点的时候把信息回复一下即可。

#include<bits/stdc++.h>
using namespace std;
const int M=1e5+5;
int val[M],n,m,dep[M],ans[M];
int stk[M],top;
vector<int>G[M];
struct Qu{int to,v,i;};
vector<Qu>Q[M];
/*找到第一个val更大的下标*/
int upper_val(int v){
    int l=1,r=top,res=0;
    while(l<=r){
        int mid=l+r>>1;
        if(v<val[stk[mid]])res=mid,l=mid+1;
        else r=mid-1;
    }return res+1;
}
/*找到第一个dep更小的下标*/
int upper_dep(int d){
    int l=1,r=top,res=0;
    while(l<=r){
        int mid=l+r>>1;
        if(dep[stk[mid]]<d)res=mid,l=mid+1;
        else r=mid-1;
    }return res;
}
void dfs(int x,int pre,int d=1){
    dep[x]=d;
    /*找到了要替换的下标*/
    int rank=upper_val(val[x]);
    int cover=stk[rank],re_size=top;
    stk[top=rank]=x;
    for(int i=0;i<Q[x].size();++i){
        int j=upper_val(Q[x][i].v)-1;
        if(!j)continue;
        int k=upper_dep(dep[Q[x][i].to]);
        ans[Q[x][i].i]=max(0,j-k);
    }
    for(int i=0;i<G[x].size();++i){
        int y=G[x][i];
        if(y!=pre)dfs(y,x,d+1);
    }
    stk[rank]=cover,top=re_size;
}
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;++i)scanf("%d",&val[i]);
    for(int i=1,x,y;i<n;++i){
        scanf("%d %d",&x,&y);
        G[y].push_back(x);
        G[x].push_back(y);
    }
    for(int i=1,x,y,c;i<=m;++i){
        scanf("%d %d %d",&x,&y,&c);
        Q[x].push_back((Qu){y,c,i});
    }
    dfs(1,-1);
    for(int i=1;i<=m;++i)printf("%d\n",ans[i]);
    return 0;
}

倍增的算法

/*
    我们通过倍增来实现
    为了解决单调的购买的条件我们定义一个数组nxt[0][i],记录i向上跳第一个比i大的节点在哪里
    为了实现这个我们可以定义一个数组mx[j][i]表示i向上跳2^j步中出现的最大值,于是mx[j][i]>c满足了二分的性质
    这样之后对于(u,v,c)我们先把u跳上来,跳的比它大的节点,如果中途就到了v就算了,之后就用nxt来跳。 
*/
#include<bits/stdc++.h>
#define PB push_back
using namespace std;
const int M=2e5+5,S=19,INF=2e9;
int nxt[S][M],fa[S][M],mx[S][M];
int n,m,val[M],dep[M],u,v,c,ans;
vector<int>G[M];
int up(int x){
    int X=x;for(int i=S-1;i>=0;--i)if(mx[i][X]<=val[x])X=fa[i][X];return X;
}
void dfs(int x=1,int f=0){
    fa[0][x]=f,mx[0][x]=val[x],dep[x]=dep[f]+1;
    for(int i=0;i<G[x].size();++i)if(G[x][i]!=f)dfs(G[x][i],x);
}
void calc(){
    scanf("%d %d %d",&u,&v,&c);
    for(int i=S-1;i>=0;--i)if(dep[fa[i][u]]>=dep[v]&&mx[i][u]<=c)u=fa[i][u];
    ans=val[u]>c;
    /*每次都跳了i<<1过了比当前的u大的点*/ 
    for(int i=S-1;i>=0;--i)if(dep[nxt[i][u]]>=dep[v])ans+=1<<i,u=nxt[i][u];
    printf("%d\n",ans);
}
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;++i)scanf("%d",val+i);
    for(int i=1,x,y;i<n;++i){scanf("%d %d",&x,&y);G[x].PB(y);G[y].PB(x);}dfs();

    for(int j=1;j<S;++j)for(int i=1;i<=n;++i)fa[j][i]=fa[j-1][fa[j-1][i]];
    for(int j=1;j<S;++j)for(int i=1;i<=n;++i)mx[j][i]=max(mx[j-1][i],mx[j-1][fa[j-1][i]]);
    /*记录第一个比i大的节点在哪里(太大就跑到0了)*/ 
    for(int i=1;i<=n;++i)nxt[0][i]=up(i);

    for(int j=1;j<S;++j)for(int i=1;i<=n;++i)nxt[j][i]=nxt[j-1][nxt[j-1][i]];

    while(m--)calc();

    return 0;
}