3388:peaks弱化版

题目描述
•有n个节点，m条边，点和边都带权
•有q个如下形式的询问：从节点x出发，经过权值不超过w的边所能到达的所有节点中，最大的点权是多少。
•n,m,q≤20w，强制在线
输入
第一行：n,m
接下来一行n个数表示点权
接下来m行表示边，每行三个数，前两个是端点，第三个是权值
接来一行是Q
接下来Q行，每行两个数x和w（均需要异或lastans，lastans初始为0）
输出
Q行
样例输入
Copy (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制)
6 7
2 1 4 3 5 6
1 2 2
1 4 3
2 4 3
4 5 4
2 3 4
3 5 2
5 6 5
5
2 3
1 7
6 7
4 7
6 7
样例输出
3
5
5
2
6
提示
涉及的所有数据均不超过100万。
Kruskal树练习题

这题改编自BZOJ的peaks加强版（有强制在线），不同在与这题直接求最大（美其名曰弱化版）。

这题Kruskal树练习题
Kruskal数是用Kruskal算法求生成树时，构造一颗二叉树：
当选入一条边时，
若这条边链接u,v两点，权值为w，
则把这条边看做一个点p，点权即是边权。
然后从p点，向u，v两点所在树的根（用并查集维护）连边。
具体如→图：

用克里斯卡尔跑一遍最小生成树
首先选A-B
然后在另一幅图（kruskal树的图）上添加一个点E，点权为A-B的边权，为1。如图：

然后选B-C
再添加点F，连接B与C的祖先：

讲到这里，kruskal树的构造方法就很明了了，具体看代码

接下来我们看这题的解法，
由克鲁斯卡尔树（由最小生成树构造）的性质：
任一点到根的路径上的点权是不下降的，
叶子节点是原图的节点，
任意两个叶子节点的LCA（最近公共祖先，不懂的自行度娘）的点权就是该两点的瓶颈边的边权；（瓶颈边：两点间每一条路径中的边权最大值的最小值，学编程这种最大值的最小值要理解透彻）
题目求的就是从指定一点出发，经过的瓶颈边权值小于（等于）某个数时能到达的点中，点权最大值（是原图）；
于是直接用kruskal树，每次从一点出发往上求点权最大并且是深度最小的点v（由Kruskal树的性质，这两个不矛盾），然后有且仅有v的整个子树就你可以到达，一次O(n)的树形DP预处理出答案就可以O(1)回答询问。

AC代码：

//我和那个C20181220杠上了
#include<cstdio> 
#include<algorithm> 
#include<cstring> 
#include<cctype> 
#include<cmath> 
#define Rep(now) for(i=fir[now];i;i=e[i].nxt)
#define maxn 189950
using namespace std; 
   
int n,m,q,dp[maxn*2],p[maxn*2]; 
   
inline void get(int &res){ 
    char ch;
    while(!isdigit(ch=getchar()));
    for(res=ch-'0';isdigit(ch=getchar());res=res*10+ch-'0'); 
}
 
inline void put(int a){
    if(a>9) put(a/10);
    putchar('0'+a%10);
}
   
struct node{ //建图
    int to,nxt; 
}e[maxn*2]; 
int fir[maxn*2],cnt_e,cnt_p; 
 
inline void Node(int u,int v){
    e[++cnt_e].to=v,e[cnt_e].nxt=fir[u],fir[u]=cnt_e;
}
   
struct line{ //最小生成树
    int u,v,w; 
    bool operator <(const line nxt)const{ 
        return w<nxt.w; 
    } 
}g[maxn]; 
 
int f[maxn*2];//并查集
inline int find(int now){
    return f[now]==now?now:f[now]=find(f[now]);
}
 
int siz[maxn*2],son[maxn*2],tp[maxn*2],fa[maxn*2],dfn[maxn*2],id[maxn*2],tmr;//轻重链剖分
inline void dfs_tr(int now){//第一次遍历
    int v,i;
    siz[now]=1;
    if(now<=n)dp[now]=p[now];
    Rep(now)
        {
            dfs_tr(v=e[i].to);
            siz[now]+=siz[v];
            fa[v]=now;
            dp[now]=max(dp[now],dp[v]);
            if(siz[v]>siz[son[now]]) son[now]=v;
        }
}
 
inline void dfs_ch(int now){ //第二次遍历
    id[dfn[now]=++tmr]=now;
    int v,i;
    if(son[now]) tp[son[now]]=tp[now],dfs_ch(son[now]);
    Rep(now)
        if((v=e[i].to)!=son[now]){
            tp[v]=v;
            dfs_ch(v);
        }
}
   
int main(){ 
    int u,v,w; 
    get(n),get(m); cnt_p=n;
    for(int i=1;i<=n;i++) get(p[i]); 
    for(int i=1;i<=m;i++) get(g[i].u),get(g[i].v),get(g[i].w); 
       
    sort(g+1,g+1+m); 
    for(int i=1;i<=(n<<1)-1;i++) f[i]=i;
    for(int i=1;i<=m;i++) 
    { 
        u=find(g[i].u),v=find(g[i].v);
        if(u!=v){
            p[++cnt_p]=g[i].w;
            Node(cnt_p,u);
            Node(cnt_p,v);
            f[u]=f[v]=cnt_p;
        }
    } 
     
    for(int i=cnt_p;i>=1;i--)
        if(!siz[i])
            dfs_tr(i);
    for(int i=cnt_p;i>=1;i--)
        if(!tp[i])
            tp[i]=i,dfs_ch(i);
     
    p[0]=1<<29;
    int lastans=0;
    get(q);
    while(q--){
        get(u),get(v);
        u^=lastans,v^=lastans;
         
        int l=dfn[u],r,mid;
        if(fa[u]&&p[fa[u]]<=v){
            while(p[fa[tp[u]]]<=v)
                u=fa[tp[u]];
            l=dfn[tp[u]],r=dfn[u];
            while(l<r){
                mid=(l+r)/2;
                if(p[id[mid]]>v) l=mid+1;
                else r=mid;
            }
        }
         
        put(lastans=dp[id[l]]);puts("");
    }
}