Maximum Label Difference in a Connected Component

You are given an undirected graph with gNodes vertices labeled from 1 through gNodes. For every index i, gFrom[i] and gTo[i] are the endpoints of one undirected edge.
For each connected component, find the difference between its largest and smallest vertex labels. Return the maximum such difference across all connected components. An isolated vertex is a connected component whose difference is 0.

Function
maximumDifference(gNodes: int, gFrom: List<Integer>, gTo: List<Integer>) → int

Examples
Example 1
gNodes = 7
gFrom = [1,2,3,5,6]
gTo = [2,4,5,7,7]
return = 4
The components are {1, 2, 4} and {3, 5, 6, 7}. Their label differences are 4 - 1 = 3 and 7 - 3 = 4, so the answer is 4.
Example 2
gNodes = 4
gFrom = []
gTo = []
return = 0
All four vertices are isolated, so every component has equal minimum and maximum labels and contributes a difference of 0.
Example 3
gNodes = 9
gFrom = [1,6,2,3,4]
gTo = [6,9,3,4,2]
return = 8
The component {1, 6, 9} has label difference 9 - 1 = 8. The cycle {2, 3, 4} has difference 2, and all remaining vertices are isolated.

Constraints
gNodes is nonnegative.
gFrom.length == gTo.length.
Every endpoint is between 1 and gNodes, inclusive.
Parallel edges and self-loops are allowed.

The trick is to group vertices into components, then track the min and max label per component. With union-find, merge each edge pair, then loop over every vertex from 1 to gNodes, find its root, and update min and max for that root. The answer is the largest max minus min. Keep a root-indexed array for both values, initialized from the vertex itself. The common pitfall is only iterating over vertices that appear in edges, which skips isolated nodes. That's harmless for the answer since they give 0, but it breaks if every vertex is isolated and you return something undefined. Another pitfall is recursion depth in find without path compression, which can blow up on long chains. Use iterative find or path halving. Self-loops and duplicate edges are fine, since union of the same root is a no-op. Total cost is near linear. If the logic slips live, StealthCoder is the hedge that hands you the solution without the proctor seeing anything.

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.