# 2421 Number of Good Paths

There is a tree (i.e. a connected, undirected graph with no cycles) consisting of `n` nodes numbered from `0` to `n - 1` and exactly `n - 1` edges.

You are given a 0-indexed integer array `vals` of length `n` where `vals[i]` denotes the value of the `ith` node. You are also given a 2D integer array `edges` where `edges[i] = [ai, bi]` denotes that there exists an undirected edge connecting nodes `ai` and `bi`.

A good path is a simple path that satisfies the following conditions:

The starting node and the ending node have the same value. All nodes between the starting node and the ending node have values less than or equal to the starting node (i.e. the starting node's value should be the maximum value along the path). Return the number of distinct good paths.

Note that a path and its reverse are counted as the same path. For example, `0 -> 1` is considered to be the same as `1 -> 0`. A single node is also considered as a valid path.

Example 1:

``````   0(1)
/    \
1(3)   2(2)
/    \
3(1)   4(3)

Input: vals = [1,3,2,1,3], edges = [[0,1],[0,2],[2,3],[2,4]]
Output: 6
Explanation: There are 5 good paths consisting of a single node.
There is 1 additional good path: 1 -> 0 -> 2 -> 4.
(The reverse path 4 -> 2 -> 0 -> 1 is treated as the same as 1 -> 0 -> 2 -> 4.)
Note that 0 -> 2 -> 3 is not a good path because vals > vals.
``````

Example 2:

``````     0(1)
/
1(1)
/
2(2)
/    \
3(2)   4(3)

Input: vals = [1,1,2,2,3], edges = [[0,1],[1,2],[2,3],[2,4]]
Output: 7
Explanation: There are 5 good paths consisting of a single node.
There are 2 additional good paths: 0 -> 1 and 2 -> 3.
``````

Example 3:

`````` 0(1)

Input: vals = , edges = []
Output: 1
Explanation: The tree consists of only one node, so there is one good path.
``````

Constraints:

• `n == vals.length`
• `1 <= n <= 3 * 104`
• `0 <= vals[i] <= 105`
• `edges.length == n - 1`
• `edges[i].length == 2`
• `0 <= ai, bi < n`
• `ai != bi`
• `edges` represents a valid tree.
 `````` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 `````` ``````class Solution: def numberOfGoodPaths(self, vals: List[int], edges: List[List[int]]) -> int: n = len(vals) parent = [i for i in range(n)] rank =  * n def find(x): if parent[x] != x: parent[x] = find(parent[x]) return parent[x] def union(x, y): hx, hy = find(x), find(y) if hx == hy: return elif rank[hx] < rank[hy]: parent[hx] = hy elif rank[hx] > rank[hy]: parent[hy] = hx else: parent[hy] = hx rank[hx] += 1 adj = defaultdict(list) for a, b in edges: adj[a].append(b) adj[b].append(a) val_to_nodes = defaultdict(list) for i in range(n): val_to_nodes[vals[i]].append(i) path_count = 0 for val in sorted(val_to_nodes.keys()): # process nodes from smallest to largest value nodes = val_to_nodes[val] for node in nodes: if node not in adj: continue for neighbor in adj[node]: if vals[node] >= vals[neighbor]: union(node, neighbor) group = defaultdict(int) for u in val_to_nodes[val]: hu = find(u) group[hu] = group[hu] + 1 for size in group.values(): path_count += size * (size + 1) // 2 return path_count``````