<p>You are given the <code>root</code> of a binary tree with <strong>unique values</strong>.</p>

<p>In one operation, you can choose any two nodes <strong>at the same level</strong> and swap their values.</p>

<p>Return <em>the minimum number of operations needed to make the values at each level sorted in a <strong>strictly increasing order</strong></em>.</p>

<p>The <strong>level</strong> of a node is the number of edges along the path between it and the root node<em>.</em></p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174006-2.png" style="width: 500px; height: 324px;" />
<pre>
<strong>Input:</strong> root = [1,4,3,7,6,8,5,null,null,null,null,9,null,10]
<strong>Output:</strong> 3
<strong>Explanation:</strong>
- Swap 4 and 3. The 2<sup>nd</sup> level becomes [3,4].
- Swap 7 and 5. The 3<sup>rd</sup> level becomes [5,6,8,7].
- Swap 8 and 7. The 3<sup>rd</sup> level becomes [5,6,7,8].
We used 3 operations so return 3.
It can be proven that 3 is the minimum number of operations needed.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174026-3.png" style="width: 400px; height: 303px;" />
<pre>
<strong>Input:</strong> root = [1,3,2,7,6,5,4]
<strong>Output:</strong> 3
<strong>Explanation:</strong>
- Swap 3 and 2. The 2<sup>nd</sup> level becomes [2,3].
- Swap 7 and 4. The 3<sup>rd</sup> level becomes [4,6,5,7].
- Swap 6 and 5. The 3<sup>rd</sup> level becomes [4,5,6,7].
We used 3 operations so return 3.
It can be proven that 3 is the minimum number of operations needed.
</pre>

<p><strong class="example">Example 3:</strong></p>
<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174052-4.png" style="width: 400px; height: 274px;" />
<pre>
<strong>Input:</strong> root = [1,2,3,4,5,6]
<strong>Output:</strong> 0
<strong>Explanation:</strong> Each level is already sorted in increasing order so return 0.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
	<li>All the values of the tree are <strong>unique</strong>.</li>
</ul>

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minimumOperations(self, root: Optional[TreeNode]) -> int:
        def minSwapsToSort(arr, n): 
            arrPos = [[0 for x in range(2)] 
                        for y in range(n)] 
            
            for i in range(n):	 
                arrPos[i][0] = arr[i] 
                arrPos[i][1] = i 
            arrPos.sort() 
            vis = [False] * (n) 
            ans = 0
            for i in range(n): 
                if (vis[i] or arrPos[i][1] == i): 
                    continue
                cycle_size = 0
                j = i 
                
                while (not vis[j]):		 
                    vis[j] = 1
                    j = arrPos[j][1] 
                    cycle_size+= 1
                
                # Update answer by 
                # adding current cycle. 
                ans += (cycle_size - 1) 
            return ans 
        def solve(a, b): 
            n=len(a)
                
            # map to store position 
            # of elements in array B 
            # we basically store 
            # element to index mapping. 
            mp = {} 
            for i in range(n): 
                mp[b[i]] = i 

            # now we're storing position 
            # of array A elements 
            # in array B. 
            for i in range(n): 
                b[i] = mp[a[i]] 
            return minSwapsToSort(b, n) 
        a=[]
        def dfs(node,h):
            if not node:return
            if h==len(a):
                a.append([])
            a[h].append(node.val)
            dfs(node.left,h+1)
            dfs(node.right,h+1)
        dfs(root,0)
        print(a)
        needed=[sorted(x) for x in a]
        print(needed)
        ans=0
        for i,arr in enumerate(a):
            ans+=solve(arr,needed[i])
        return ans
49500