Limit an Organization Tree's Height

An organization has n employees numbered from 1 to n. Employee 1 is the CEO. Each pair managers[i], reportees[i] is a directed edge from a manager to a direct report. The edges form a rooted tree.
An employee's level is its number of edges from the CEO, so the CEO is at level 0. The tree's height is its maximum employee level.
Restructuring Rule
The organization wants height at most maxHeight. In one change, choose any non-CEO employee and make that employee report directly to the CEO. The employee's entire subtree moves with them and otherwise remains unchanged.
Return [originalHeight, minimumChanges], where minimumChanges is the fewest direct-report changes needed to make the final height at most maxHeight.
Interviewer follow-ups
The interview begins by asking for the deepest employee level. The follow-up adds the maximum-height policy and asks candidates to minimize how many employees must become direct reports of the CEO.

Function
analyzeOrgTree(n: int, managers: int[], reportees: int[], maxHeight: int) → int[]

Examples
Example 1
n = 6
managers = [1,2,3,4,1]
reportees = [2,3,4,5,6]
maxHeight = 2
return = [4,1]
The chain 1-2-3-4-5 gives an original height of 4. Making employee 3 report to the CEO changes that chain to 1-3-4-5, whose deepest level is 3, so it does not satisfy maxHeight = 2. Instead, make employee 4 report to the CEO, leaving employee 5 at level 2. One change is sufficient.
Example 2
n = 5
managers = [1,1,2,2]
reportees = [2,3,4,5]
maxHeight = 2
return = [2,0]
The original tree already has height 2, so no direct-report change is needed.

Constraints
2 <= n <= 200000
managers.length = reportees.length = n - 1
1 <= maxHeight < n
The edges form a tree rooted at employee 1.

Build the child lists, then compute each node's level and its subtree height (longest path down to a leaf). Moving a node to the CEO puts it at level 1, so its deepest descendant lands at 1 + height(node). The greedy: process bottom-up, and cut a node exactly when its height reaches maxHeight - 1 and it isn't already a direct report of the CEO. Cutting resets that subtree, so the parent sees a smaller height. Pitfall: cutting too high, like employee 3 in Example 1, which still leaves depth 3. Cut the deepest-possible node, the one whose subtree height hits the limit. Use an iterative DFS or BFS order because n goes to 200000 and recursion will overflow. The first answer is just the max level. StealthCoder is your hedge if the greedy argument escapes you live, but the post-order count is short once you see it.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.