Credits to FLEA for teaching me this trick.

Introduction

Recently I learnt an interesting trick I wanted to share with others. I'm not sure if this trick is well known, but I didn't know about it and didn't find any other articles on it so decided to write this blog.

Problem statement

We have a connected undirected graph with $$$n$$$ nodes and $$$m$$$ edges between them, each node having a value $$$w_i$$$ ($$$1 <= n, m <= 10^5$$$), ($$$1 <= w_i <= 10^9$$$).

Let's denote $$$f(a, b)$$$ as the minimum value of a node on a path from node $$$a$$$ to node $$$b$$$.

We have to answer $$$q$$$ queries about this graph. Each query contains $$$2$$$ nodes $$$a$$$, $$$b$$$ and asks for the maximum $$$f(a, b)$$$ over all possible paths from node $$$a$$$ to node $$$b$$$. ($$$1 <= q <= 10^5$$$).

Notes

This problem can be solved in another (more optimal) way, which is described in these comments: 1, 2. Thanks to valeriu and geniucos for mentioning it!

A similar idea from stefdasca.

Prerequisites

In order to fully understand the idea you have to know about DSU (disjoint set union) and small to large merging.

Solution

We will do some kind of DSU (disjoint set union). For each node, we don't only keep its parent, but also the queries it appears in (we store them in a map/set). Then we go through all the $$$n$$$ nodes in decreasing order of their values. When we are at a node — $$$u$$$, we "activate" it and then go through all the already activated neighbors the node has and we merge these two nodes.

How do we merge them?

First, we do the simple merge of the $$$2$$$ components with the classic $$$par[a] = b$$$. Then, we go through all queries the node is responsible for and check if it also appears in the query of the other node. If it does, we set the answer of that query to the weight of the node we are currently considering, since we know it will be the minimum on the path (because we are going through nodes in decreasing order of their values), if they don't both appear we just insert the the given query to the combined component and continue. But, since it would take too long, we merge the query sets with small to large merging (merge the node which has a smaller (in size) query set to the one that has a larger one). So, we do all this in $$$O((n + m) log^2n)$$$.

Some code

Note: ans[i] is the answer for query with index $$$i$$$.

First of all, we need the DSU functions — get (which returns the node responsible for the whole component) and union, which merges $$$2$$$ different components.

Since the only things we care about for a node are its parent and set of queries it's responsible for we can keep a pair of an integer and a map/set.

The union, as discussed in the above solution part involves small to large merging. If both nodes are responsible for a query then the answer for the query is the weight of the other node, otherwise we insert the query to the combined component.

const int N = 1e5 + 10;

vector<pair<int,int>> adj[N];

pair<int, map<int, int>> d[N];

int get(int u) {
    if(u == d[u].first) return u;
    return d[u].first = get(d[u].first);
}

void uni(int a, int b, int c) {
    a = get(a), b = get(b);

    if(d[a].second.size() > d[b].second.size()) {
        swap(a, b);
    }

    d[a].first = b;
    for(auto i: d[a].second) {
        if(d[b].second.count(i.first)) {
            ans[i.first] = c;
        } else d[b].second[i.first] = 1;
    }
}

After that, we need to set the initial components. Initially, nodes should have an empty query set and their parent should be themself only, and we can sort the nodes by decreasing order of their values in the same time (vector v will contain the node index on the second position). And, we can go also go through queries and add the queries responsible for a given node to a list.

vector<pair<ll, int>> v;

for(int i = 0;i < n; ++i) {
   v.pb({dist[i], i});
   d[i] = {i, {}};
   d[i].second.clear();
}
sort(v.rbegin(), v.rend());
int qq;
cin >> qq; // scanning the number of queries and node a, b of each query
vector<pair<int,int>> qr(qq);
vector<int> responsible_queries[N];
for(int i = 0;i < qq; ++i) {
   cin >> qr[i].first >> qr[i].second;
   --qr[i].first, --qr[i].second;
    responsible_queries[qr[i].first].pb(i);
    responsible_queries[qr[i].second].pb(i);
}

Now for the iteration in decreasing order of the values, we keep the boolean activated for each node, which tells us whether the node was already "activated" (gone through) or not.

vector<bool> activated(n, false);
    for(auto ff : v) {
        int u = ff.second, w = ff.first; //u - node, w - its value
        int l = get(u); //l - parent responsible for the component of the node
        activated[u] = true;
        for(int z: responsible_queries[u]) {
            if(!d[l].second.count(z))
                d[l].second[z] = 1; //we add the query to the set of queries the node is responsible for.
            else ans[z] = w; //The node is an endpoint of a query and its the smallest when merged to it, so the answer for the query is just the value of the node.
        }
        for(auto yy: adj[u]) {
            int ng = yy.first;
            if(activated[ng]){
                uni(u, ng, w); //if the node is activated we merge them in the manner described above.
            }
        }
    }

Then, we are left with outputting the answer for each query.

Variations

This trick can solve many variations of the problem, the most obvious one being that $$$f(a, b)$$$ would be the maximum value on the path instead of the minimum, which would require their little modifications