124_Binary_Tree_Maximum_Path_Sum

Author: Partho Biswas

README.md

@@ -428,7 +428,7 @@ Check this [golden](https://tinyurl.com/ujopecz) post.
 |10| [105. Construct Binary Tree from Preorder and Inorder Traversal](https://tinyurl.com/y4s62xbu)| [Python](https://tinyurl.com/wu6rdaw/105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.py)| [Art 1](https://tinyurl.com/y3megvpm), [Art 2](https://tinyurl.com/tazaoyz), [Vid 1](https://tinyurl.com/qoqdsqv) | Medium | DFS, Very Important |
 |11| [106. Construct Binary Tree from Inorder and Postorder Traversal](https://tinyurl.com/yx78og6g)| [Python](https://tinyurl.com/wu6rdaw/106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.py), [Swift](https://tinyurl.com/wuja3c4/106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.swift) | [Art 1](https://tinyurl.com/vlntqrp) | Medium | DFS, Very Important |
 |12| **[889. Construct Binary Tree from Preorder and Postorder Traversal](https://tinyurl.com/y578ty5u)** | [Python](https://tinyurl.com/wu6rdaw/889_Construct_Binary_Tree_from_Preorder_and_Postorder_Traversal.py)| [Vid 1](https://tinyurl.com/r6d4ym5), **[Art 1](https://tinyurl.com/tflqhp9)**, [Art 2](https://tinyurl.com/wkq7qyu) | Medium | 📌 **TODO: Check again. Important** |
-|13| **[124. Binary Tree Maximum Path Sum](https://tinyurl.com/yycvxmmy)**| [Python](https://tinyurl.com/wu6rdaw/124_Binary_Tree_Maximum_Path_Sum.py)| [Art 1](https://tinyurl.com/uocr9np), [Art 2](https://tinyurl.com/s23sqhe), [Vid 1](https://tinyurl.com/wwe95qx), [AlgoExpert](https://tinyurl.com/vofbonm) | Very Hard | **Very important and tricky** |
+|13| **[124. Binary Tree Maximum Path Sum](https://tinyurl.com/yycvxmmy)**| [Python](https://tinyurl.com/wu6rdaw/124_Binary_Tree_Maximum_Path_Sum.py), [Swift](https://tinyurl.com/wuja3c4/124_Binary_Tree_Maximum_Path_Sum.swift) | [Art 1](https://tinyurl.com/uocr9np), [Art 2](https://tinyurl.com/s23sqhe), [Vid 1](https://tinyurl.com/wwe95qx), [AlgoExpert](https://tinyurl.com/vofbonm) | Very Hard | **Very important and tricky** |
 |14| **[979. Distribute Coins in Binary Tree](https://leetcode.com/problems/distribute-coins-in-binary-tree/)**| [Python](https://tinyurl.com/wu6rdaw/979_Distribute_Coins_in_Binary_Tree.py)| [Art 1](https://tinyurl.com/rugoa38), [Art 2](https://tinyurl.com/whkdbl4), [Art 3](https://tinyurl.com/s62fws7) | Medium | **Very important. Postorder DFS** |
 |15| [116. Populating Next Right Pointers in Each Node](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/)| [Python](https://tinyurl.com/wu6rdaw/116_Populating_Next_Right_Pointers_in_Each_Node.py)| [Art 1](https://tinyurl.com/t6p8kjb), [Art 2](https://tinyurl.com/ujzrhkj), **[Art 3](https://tinyurl.com/unrow77)** | Medium | BFS/DFS, Level order traversal |
 |16| [117. Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/)| [Python](https://tinyurl.com/wu6rdaw/117_Populating_Next_Right_Pointers_in_Each_Node_II.py)| [Vid 1](https://tinyurl.com/rfjhzj3), [Vid 2](https://tinyurl.com/ryghj42) | Medium | **Very tricky, check again** |

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/124_Binary_Tree_Maximum_Path_Sum.swift

@@ -0,0 +1,35 @@
+import Foundation
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func maxPathSum(_ root: TreeNode?) -> Int {
+        var maxSumResult: Int = Int.min
+        maxPathSumDFSHelper(root, &maxSumResult)
+        return maxSumResult
+    }
+    
+    private func maxPathSumDFSHelper(_ root: TreeNode?, _ maxSumResult: inout Int) -> Int {
+        guard let root = root else {
+            return 0
+        }
+        let leftMaxSum = maxPathSumDFSHelper(root.left, &maxSumResult)
+        let rightMaxSum = maxPathSumDFSHelper(root.right, &maxSumResult)
+        
+        maxSumResult = [maxSumResult, root.val, root.val + leftMaxSum, root.val + rightMaxSum, root.val + leftMaxSum + rightMaxSum].max()!
+        
+        return [root.val, root.val + leftMaxSum, root.val + rightMaxSum].max()!
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1269_Number_of_Ways_to_Stay_in_the_Same_Place_After_Some_Steps.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+// BruteForce. Time: O(arrayLen*3^steps). TLE. 12 / 31 test cases passed.
+class Solution {
+    func numWays(_ steps: Int, _ arrLen: Int) -> Int {
+        var totalWays = 0
+        numWaysDFSHelper(steps, arrLen, 0, 1, &totalWays)
+        return totalWays
+    }
+    
+    private func numWaysDFSHelper(_ steps: Int, _ arrLen: Int, _ currentIndex: Int, _ currentSteps: Int, _ totalWays: inout Int) {
+        if currentSteps > steps {
+            if currentIndex == 0 {
+                totalWays += 1
+                totalWays = totalWays % (Int(pow(Double(10), Double(9))) + 7)
+            }
+            return
+        }
+        
+        for i in [0, -1, 1] {
+            let newIndex = currentIndex + i
+            if newIndex >= 0 && newIndex < arrLen {
+                numWaysDFSHelper(steps, arrLen, newIndex, currentSteps + 1, &totalWays)
+            }
+        }
+    }
+}
+
+// BruteForce with memoization. Time: O(arrayLen*3^steps).
+class Solution {
+    func numWays(_ steps: Int, _ arrLen: Int) -> Int {
+        var memo = [String:Int]()
+        numWaysDFSHelper(steps, arrLen, 0, 1, &memo)
+        print(memo)
+        return memo["0-0"] ?? 0
+    }
+    
+    private func numWaysDFSHelper(_ steps: Int, _ arrLen: Int, _ currentIndex: Int, _ currentSteps: Int, _ memo: inout [String:Int]) {
+        if let totalwaysFromMemo = memo["\(currentIndex)-\(steps - currentSteps)"] {
+            memo["\(currentIndex)-\(steps - currentSteps)"] = totalwaysFromMemo + 1
+            return
+        }
+        if currentSteps > steps {
+            if currentIndex == 0 {
+                if let totalwaysFromMemo = memo["0-0"] {
+                    memo["0-0"] = (totalwaysFromMemo + 1) % (Int(pow(Double(10), Double(9))) + 7)
+                } else {
+                    memo["0-0"] = 1
+                }
+            }
+            return
+        }
+        
+        for i in [0, -1, 1] {
+            let newIndex = currentIndex + i
+            if newIndex >= 0 && newIndex < arrLen && newIndex <= steps {
+                if let totalwaysFromMemo = memo["\(newIndex)-\(steps - currentSteps - 1)"] {
+                    memo["\(newIndex)-\(steps - currentSteps - 1)"] = totalwaysFromMemo + 1
+                } else {
+                    numWaysDFSHelper(steps, arrLen, newIndex, currentSteps + 1, &memo)
+                    memo["\(newIndex)-\(steps - currentSteps - 1)"] = totalwaysFromMemo + 1
+                }
+            }
+        }
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/536_Construct_Binary_Tree_from_String.swift

@@ -0,0 +1,58 @@
+import Foundation
+
+public class TreeNode {
+    public var val: Int
+    public var left: TreeNode?
+    public var right: TreeNode?
+    public init() { self.val = 0; self.left = nil; self.right = nil; }
+    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+    public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+        self.val = val
+        self.left = left
+        self.right = right
+    }
+}
+
+class Solution {
+    func str2tree(_ s: String) -> TreeNode? {
+        guard s.count > 0, var str: [Character] = Array(s) else {
+            return nil
+        }
+        var currentIndex = 0
+        return str2treeDFSHelper(str, &currentIndex)
+    }
+    
+    private func str2treeDFSHelper(_ strArr: [Character], _ currentIndec: inout Int) -> TreeNode? {
+        guard currentIndec < strArr.count else {
+            return nil
+        }
+        
+        print("Index:   \(currentIndec), value:   \(strArr[currentIndec].wholeNumberValue)")
+        var currentNodeVal: Int = strArr[currentIndec].wholeNumberValue!
+        currentIndec += 1
+        while currentIndec < strArr.count {
+            if strArr[currentIndec].isWholeNumber {
+                currentNodeVal = currentNodeVal*10 + strArr[currentIndec].wholeNumberValue!
+                currentIndec += 1
+            } else {
+                break
+            }
+        }
+        
+        var currentNode: TreeNode = TreeNode(currentNodeVal)
+        if String(strArr[currentIndec]) == "(" {
+            currentIndec += 1
+            var left: TreeNode? = str2treeDFSHelper(strArr, &currentIndec)
+            currentNode.left = left
+            
+            currentIndec += 1
+            var right: TreeNode? = str2treeDFSHelper(strArr, &currentIndec)
+            currentNode.right = right
+        } else if String(strArr[currentIndec]) == ")" {
+            return currentNode
+        }
+        
+        
+        return currentNode
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/855_Exam_Room.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+class ExamRoom {
+    var n = 1
+    var occupiedSeates = Set<Int>()
+    var maxIntervalHeap = [Int]() // A max Heap of interval value
+    var maxIntervalRangeMap = [Int:[(Int, Int)]]() // key = max interval, value = lower and upper range of the interval
+
+    init(_ N: Int) {
+        self.n = N
+    }
+    
+    func seat() -> Int {
+        if occupiedSeates.count <= 0 {
+            occupiedSeates.insert(0)
+            return 0
+        } else {
+            
+        }
+    }
+    
+    func leave(_ p: Int) {
+        occupiedSeates.remove(p)
+        
+    }
+}
+
+/**
+ * Your ExamRoom object will be instantiated and called as such:
+ * let obj = ExamRoom(N)
+ * let ret_1: Int = obj.seat()
+ * obj.leave(p)
+ */

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/93_Restore_IP_Addresses.swift

@@ -1,2 +1,39 @@
 import Foundation
 
+import Foundation
+
+class Solution {
+    func restoreIpAddresses(_ s: String) -> [String] {
+        let digits: [Int] = Array(s).compactMap { $0.wholeNumberValue }
+        guard digits.count >= 4 else {
+            return []
+        }
+        
+        var allAdress = [String]()
+        restoreIpAddressesDFSHelper(digits, 0, [], &allAdress)
+        return allAdress
+    }
+    
+    private func restoreIpAddressesDFSHelper(_ digits: [Int], _ currentIdx: Int, _ currentAdress: [Int], _ allAdress: inout [String]) {
+        if currentIdx >= digits.count && currentAdress.count == 4 {
+            var currentAddrStr = currentAdress.map { String($0) }.joined(separator: ".")
+            if currentAddrStr.count == digits.count + 3 {
+                allAdress.append(currentAddrStr)
+            }
+            return
+        }
+        if currentAdress.count > 4 || currentIdx >= digits.count || (currentAdress.count >= 3 && (digits[currentIdx...].count > 3 || Int(digits[currentIdx...].map { String($0) }.reduce("", +))! > 255)) {
+            return
+        }
+        var currentNum = 0
+        for i in currentIdx..<min(currentIdx + 3, digits.count) {
+            currentNum = currentNum*10 + digits[i]
+            if currentNum >= 0 && currentNum <= 255 {
+                restoreIpAddressesDFSHelper(digits, i + 1, currentAdress + [currentNum], &allAdress)
+            } else {
+                break
+            }
+        }
+        return
+    }
+}