A good way to get the intuition is by thinking what if no minimax path lie on the MST? It comes back to the edges we choose in a cycle. We cut the edge with the highest weight to make the MST so among all paths that were accessible in the original graph, only the ones with the heaviest edges are inaccessible in the MST.

There are several ways to implement this, one that I thought of is this:

#define vpii vector<pair<int,int>>
#define pii pair<int,int>
#define pb push_back
#define vi vector<int>
vpii vertexMST(vpii edges, vi weight){
        int m = edges.size();
        int n = weight.size();
        //add v,u for all u,v in the list
        for(int i=0;i<m;i++){
                edges.pb({edges[i].second,edges[i].first});
        }
        //sort based on weight of first vertex
        sort(edges.begin(),edges.end(),[&](pii a,pii b){
                return weight[a.first] < weight[b.first];
        });

        vpii new_edges;
        vi vis(n,0);
        for(auto it:edges){
                int u = it.first;
                int v = it.second;
                //if we haven't added vertex u to our tree/forest yet then add it
                if(!vis[u])
                        vis[u] = 1;
                //if adding vertex v doesn't create a cycle and v is in our tree/forest then add it
                if(dsu.find(u) != dsu.find(v) and vis[v]){
                        new_edges.pb({u,v});
                        dsu.merge(u,v);
                }
        }
        return new_edges;
}

1. The lowest vlad's energy can go throughout his travel is by $$$h_{max}$$$ — $$$h_{initial}$$$, where $$$h_{max}$$$ is the highest mountain in his path, and $$$h_{initial}$$$ is the height of his first mountain.
2. If vlad can travel between u and v with energy e, there will always exist a simple path which he can travel along. (Think about what effect does going in a loop or repeating an edge do the energy)

From our initial observations, we can deduce that this problem is equivalent to finding the minimum possible $$$h_{max}$$$ in the journey from $$$u$$$ to $$$v$$$, and then checking if $$$h_{max}$$$ — $$$h_u$$$ $$$\leq$$$ $$$e$$$.

So we first create the vertex MST, then after rooting the tree at an arbitrary node, then using the technique of binary lifting we precompute ancestors in powers of 2 and also maximum weighted node in the path to that ancestor.

Hence whenever we get a query for two vertices $$$u$$$ and $$$v$$$, we can just find their LCA (Lowest common ancestor) and take the max of the maximum weighted node from each of the vertex to the LCA and that would be our $$$h_{max}$$$ for the path from $$$u$$$ to $$$v$$$!

precomputation : $$$O(n\log (n))$$$ query time : $$$O(\log (n))$$$