Merge pull request 'Diameter of a Binary Tree' (#2) from dia_binary_tree into main

Reviewed-on: #2

python/problem_543/README.md

@@ -0,0 +1,27 @@
+# 543. Diameter of Binary Tree
+
+Given the root of a binary tree, return the length of the diameter of the tree.
+
+The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.
+
+The length of a path between two nodes is represented by the number of edges between them.
+
+
+
+Example 1:
+
+Input: root = [1,2,3,4,5]
+Output: 3
+Explanation: 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+
+Example 2:
+
+Input: root = [1,2]
+Output: 1
+
+
+
+Constraints:
+
+    The number of nodes in the tree is in the range [1, 104].
+    -100 <= Node.val <= 100

python/problem_543/solution1.py

@@ -0,0 +1,30 @@
+# 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 diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        diameter = 0
+
+        def longest_path(node):
+            # nonlocal to access the diameter when doing recursion
+            nonlocal diameter
+            # if no child
+            if not node:
+                return 0
+
+            # calculate the longest path for left and right
+            left_longest = longest_path(node.left)
+            right_longest = longest_path(node.right)
+
+            # check if its bigger than diameter
+            diameter = max(diameter, left_longest + right_longest)
+
+            # add the edge to parent while returning
+            return max(left_longest, right_longest) + 1
+
+        # do post-tree traversal
+        longest_path(root)
+        return diameter

python/problem_670/README.md

@@ -0,0 +1,25 @@
+# 670. Maximum Swap
+
+You are given an integer num. You can swap two digits at most once to get the maximum valued number.
+
+Return the maximum valued number you can get.
+
+
+
+Example 1:
+
+Input: num = 2736
+Output: 7236
+Explanation: Swap the number 2 and the number 7.
+
+Example 2:
+
+Input: num = 9973
+Output: 9973
+Explanation: No swap.
+
+
+
+Constraints:
+
+    0 <= num <= 108

python/problem_670/solution1.py

@@ -0,0 +1,28 @@
+class Solution:
+    def maximumSwap(self, num: int) -> int:
+        # we need to track what is the highest number
+        # from the right of current idx
+
+        # convert the int to str
+        str_num = list(str(num))
+        n = len(str_num)
+
+        max_right_idx = [0] * n
+        # last idx will always be same
+        max_right_idx[n - 1] = n - 1
+
+        for i in range(n - 2, -1, -1):
+            # if the current number is greater than max of the right
+            if str_num[i] > str_num[max_right_idx[i + 1]]:
+                max_right_idx[i] = i
+            # keep the max from right
+            else:
+                max_right_idx[i] = max_right_idx[i + 1]
+
+        # now we go from left to right
+        for j in range(n):
+            if str_num[j] < str_num[max_right_idx[j]]:
+                str_num[j], str_num[max_right_idx[j]] = str_num[max_right_idx[j]], str_num[j]
+                return int("".join(str_num))
+
+        return num