<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:
    class DS
    {
        public:
        vector<int>par,size;
        DS(int n)
        {
            par.resize(n+1);
            size.resize(n+1);
            for(int i=0;i<n;i++)
            {
                par[i] = i;
                size[i]=1;
            }
        }
        int parent(int node)
        {
            while(node!=par[node])
            {
                node = par[node];
            }
            return node;
        }
        void US(int node1,int node2)
        {
            int p1 = par[node1];
            int p2 = par[node2];
            if(p1==p2)
            {
                return;
            }
            if(size[p1]>size[p2])
            {
                size[p1]+=size[p2];
                par[p2]=p1;
            }
            else
            {
                par[p1] = p2;
                size[p2]+=size[p1];
            }
        }
    };
    vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>&edge, vector<vector<int>>&que) {
        DS ds(n);
        vector<pair<int,vector<int>>>vp;
        vector<pair<int,vector<int>>>ve;
        for(int i=0;i<edge.size();i++)
        {
            ve.push_back({edge[i][2],{edge[i][0],edge[i][1]}});
            ve.push_back({edge[i][2],{edge[i][1],edge[i][0]}});
        }
       sort(ve.begin(),ve.end());
       for(int i=0;i<que.size();i++)
       {
         vp.push_back({que[i][2],{que[i][0],que[i][1],i}});
       }
       sort(vp.begin(),vp.end());
       vector<bool>ans(que.size(),false);
       int a=0;
       for(int i=0;i<que.size();i++)
       {
          int cost = vp[i].first;
          for(int j=a;j<ve.size();j++)
          {
             int nc = ve[j].first;
             cout<<cost<<" "<<nc<<" "<<endl;
             if(nc<cost)
             {
                int p1 = ds.parent(ve[j].second[0]);
                int p2 = ds.parent(ve[j].second[1]);
                if(ds.parent(ve[j].second[0])!=ds.parent(ve[j].second[1]))
                ds.US(p1,p2);
             }
             else
             {
                a = j;break;
             }
          }
          int n1 = vp[i].second[0];
          int n2 = vp[i].second[1];
          if(ds.parent(n1)==ds.parent(n2))
          {
            int ind = vp[i].second[2];
            ans[ind]=true;
          }
          //cout<<n1<<" "<<n2<<endl;
       }
       return ans;
    }
};
181735