<p>An undirected graph of <code>n</code> nodes is defined by <code>edgeList</code>, where <code>edgeList[i] = [u<sub>i</sub>, v<sub>i</sub>, dis<sub>i</sub>]</code> denotes an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with distance <code>dis<sub>i</sub></code>. Note that there may be <strong>multiple</strong> edges between two nodes.</p>

<p>Given an array <code>queries</code>, where <code>queries[j] = [p<sub>j</sub>, q<sub>j</sub>, limit<sub>j</sub>]</code>, your task is to determine for each <code>queries[j]</code> whether there is a path between <code>p<sub>j</sub></code> and <code>q<sub>j</sub></code><sub> </sub>such that each edge on the path has a distance <strong>strictly less than</strong> <code>limit<sub>j</sub></code> .</p>

<p>Return <em>a <strong>boolean array</strong> </em><code>answer</code><em>, where </em><code>answer.length == queries.length</code> <em>and the </em><code>j<sup>th</sup></code> <em>value of </em><code>answer</code> <em>is </em><code>true</code><em> if there is a path for </em><code>queries[j]</code><em> is </em><code>true</code><em>, and </em><code>false</code><em> otherwise</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/12/08/h.png" style="width: 267px; height: 262px;" />
<pre>
<strong>Input:</strong> n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
<strong>Output:</strong> [false,true]
<strong>Explanation:</strong> The above figure shows the given graph. Note that there are two overlapping edges between 0 and 1 with distances 2 and 16.
For the first query, between 0 and 1 there is no path where each distance is less than 2, thus we return false for this query.
For the second query, there is a path (0 -&gt; 1 -&gt; 2) of two edges with distances less than 5, thus we return true for this query.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/12/08/q.png" style="width: 390px; height: 358px;" />
<pre>
<strong>Input:</strong> n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
<strong>Output:</strong> [true,false]
<strong>Explanation:</strong> The above figure shows the given graph.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= edgeList.length, queries.length &lt;= 10<sup>5</sup></code></li>
	<li><code>edgeList[i].length == 3</code></li>
	<li><code>queries[j].length == 3</code></li>
	<li><code>0 &lt;= u<sub>i</sub>, v<sub>i</sub>, p<sub>j</sub>, q<sub>j</sub> &lt;= n - 1</code></li>
	<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
	<li><code>p<sub>j</sub> != q<sub>j</sub></code></li>
	<li><code>1 &lt;= dis<sub>i</sub>, limit<sub>j</sub> &lt;= 10<sup>9</sup></code></li>
	<li>There may be <strong>multiple</strong> edges between two nodes.</li>
</ul>

class Solution {
public:
    using int2 = pair<int, int>;
    using myQueue = priority_queue<int2, vector<int2>, greater<int2>>;

    vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) {
        for(int i = 0; i < queries.size(); i++){
            queries[i].push_back(i);
        }
        sort(queries.begin(), queries.end(), [](vector<int>& a, vector<int> b){
            return a[2] < b[2];
        });
        myQueue q;
        for(int i = 0; i< edgeList.size(); i++){
            if(edgeList[i][0] > edgeList[i][1]){
                swap(edgeList[i][0], edgeList[i][1]);
            }
        }
        sort(edgeList.begin(), edgeList.end());
        for(int i = 0; i< edgeList.size(); i++){
            if(i == 0 || (edgeList[i][0] != edgeList[i-1][0] || edgeList[i][1] != edgeList[i-1][1]))
                q.push({edgeList[i][2], i});
        }

        vector<int> setId(n, -1);
        int id = 0;
        unordered_map<int, vector<int>> idToSet;
        vector<bool> ans(queries.size(), false);
        for(int i = 0; i < queries.size(); i++){
            int limit = queries[i][2];
            int from = queries[i][0];
            int to = queries[i][1];
            if(setId[from] == setId[to] && setId[from] != -1){
                ans[queries[i][3]] = true;
                continue;
            }
            
            while(!q.empty() && q.top().first < limit){
                int j = q.top().second;
                q.pop();
                int node_a = edgeList[j][0];
                int node_b = edgeList[j][1];
                if(setId[node_a] == -1 && setId[node_b] == -1){
                    idToSet[id] = {node_a, node_b};
                    setId[node_a] = setId[node_b] = id;
                    id++;
                }
                else if(setId[node_a] == -1){
                    idToSet[setId[node_b]].push_back(node_a);
                    setId[node_a] = setId[node_b];
                }
                else if(setId[node_b] == -1){
                    idToSet[setId[node_a]].push_back(node_b);
                    setId[node_b] = setId[node_a];
                }
                else if(setId[node_b] != setId[node_a]){
                    auto& va = idToSet[setId[node_a]];
                    auto& vb = idToSet[setId[node_b]];
                    if(va.size() > vb.size()){
                        int id_b = setId[node_b];
                        for(int n_b: idToSet[id_b]){
                            setId[n_b] = setId[node_a];
                        }
                        va.insert(va.end(), vb.begin(), vb.end());
                        idToSet.erase(id_b);
                    }
                    else{
                        int id_a = setId[node_a];
                        for(int n_a: idToSet[id_a]){
                            setId[n_a] = setId[node_b];
                        }
                        vb.insert(vb.end(), va.begin(), va.end());
                        idToSet.erase(id_a);
                    }
                }
            }
            ans[queries[i][3]] = (setId[from] != -1 && setId[to] != -1 && setId[from] == setId[to]);

        }
        return ans;
    }
};
191962