Python, solution with classic MST + DSU
IntuitionBuilt MST incrementally, accoording to queries' theshold (preliminary presorted)
DSU structure used to check after each MST build step to verify either
# Intuition
Built MST incrementally, accoording to queries' theshold (preliminary presorted)
DSU structure used to check after each MST build step to verify either vertes of current query belongs to the same set (path exists)

# Approach
<!-- Describe your approach to solving the problem. -->

# Complexity
- Time complexity:
O(NlogN)

- Space complexity:
O(N)

# Code
```python3 []
class Solution:
    def distanceLimitedPathsExist(self, n: int, edgeList: List[List[int]], queries: List[List[int]]) -> List[bool]:        
        q_len = len(queries)   
        
        # classic DSU  - list PCH/representatives
        r = list(range(n))    

        # DSU struct & methods
        def get_repr(n)->int:            
            if r[n] != n:
                r[n] = get_repr(r[n])
            return r[n]
        
        def unite(a, b)->None:
            r_a = get_repr(a)
            r_b = get_repr(b)
            r[r_b] = r_a

        # presort both, starting from least distance
        queries  = sorted([[*arr, pos] for pos, arr in enumerate(queries)], key = lambda x: x[2], reverse = True)
        edgeList = sorted(edgeList, key = lambda x: x[2], reverse = True)
        # we need preserve queries original positions, to return answer in the same order
        ret = {}
        
        while queries:
            a, b, d, q_pos = queries.pop()
            #print(f"query {a} {b} {d}. MST = {r}") 

            # build Min Spanning Tree, while distance is less than next query allows
            while edgeList and edgeList[-1][2] < d:
                e_from, e_to, _ = edgeList.pop()
                #print(f"\tedge {e_from} {e_to} {e_d}.") 
                # check: no loops
                if r[e_from] != r[e_to]:
                    unite(e_from, e_to)
                    #print(f"\tadding edge to MST {r}")

            # check answer, either parent is same (united)
            ret[q_pos] = get_repr(r[a]) == get_repr(r[b])
            #print(f"\t answer {ret[q_pos]}") 
        
        # return answers in original order
        return [ret[i] for i in range(q_len)]
        
```
['Python3']