<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>

using ll = long long;
using pl = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vll = vector<pair<ll,ll>>;

#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()

void read(vl& a){for(auto &x : a) cin >> x;}
void read(vll& a){for(auto &x : a) cin >> x.first >> x.second;}
void read(vvl& a){for(auto &i : a) for(auto &x : i) cin >> x;}
void print(ll a){ cout<<a<<"\n";}
void print(string s){cout<<s<<"\n";}
void print(pl a){ cout<<a.first<<" "<<a.second<<" ";cout<<"\n";}
void print(vl a){for(auto x : a) cout<<x<<" ";cout<<"\n";}
void print(vll a){for(auto x : a) cout<<x.first<<" "<<x.second<<"\n";}
void print(vvl a){for(auto &&x : a){for(auto &&i : x)cout<<i<<" ";cout<<"\n";}}

class Solution {
public:

struct DSU{
    
    vl parent;
    vl size;
    ll components;

    DSU(ll n){

        parent.resize(n);
        size.resize(n,1);
        iota(all(parent),0);
        components = n;

    }

    ll find(ll x){
        return parent[x] == x ? x : parent[x] = find(parent[x]);
    }

    void unite(ll x,ll y){
        x = find(x);
        y = find(y);
        if(x != y){
            if(size[x] < size[y]) swap(x,y);
            parent[y] = x;
            size[x] += size[y];
            components--;
        }
    }

    bool same(ll x,ll y){
        return find(x) == find(y);
    }

    ll getSize(ll x){
        return size[find(x)];
    }

};

vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& e, vector<vector<int>>& q) {

    DSU d(n);vector<pair<bool,int>> ans;
    vvl ed;for(ll i=0;i<e.size();i++)ed.push_back({e[i][2],e[i][0],e[i][1]});
    vvl qt;for(ll i=0;i<q.size();i++)qt.push_back({q[i][0],q[i][1],q[i][2],i});
    sort(all(qt),[&](vl a,vl b){return a[2] < b[2];});
    sort(all(ed),[&](vl a,vl b){return a[0] < b[0];});


    ll i = 0,j = 0; 
    while(j<qt.size()){

        while(i<ed.size() and ed[i][0] < qt[j][2]){
            d.unite(ed[i][2],ed[i][1]);
            i++;
        }

        ans.push_back({d.same(qt[j][0],qt[j][1]),qt[j][3]});
        j++;

    }

    sort(all(ans),[&](pair<bool,int> a,pair<bool,int> b){return a.second < b.second;});
    
    vector<bool> res;
    for(auto x : ans)res.push_back(x.first);

    return res;
        
}

};
278896