add more solutions

Author: SocialfiPanda

Binary Tree Maximum Path Sum.py

@@ -0,0 +1,13 @@
+class Solution:
+    maxSum = -2147483648
+    def maxPathSum(self, root):
+        self.maxPathRecur(root)
+        return self.maxSum
+        
+    def maxPathRecur(self, root):
+        if root == None:
+            return 0
+        left = max(0, self.maxPathRecur(root.left))
+        right = max(0, self.maxPathRecur(root.right))
+        self.maxSum = max(self.maxSum, left + right + root.val)
+        return root.val + max(left, right)

Clone Graph.py

@@ -0,0 +1,19 @@
+class Solution:
+    def cloneGraph(self, node):
+        if node == None:
+            return None
+        start = UndirectedGraphNode(node.label)
+        map, current = {node: start}, [node]
+        while len(current) > 0:
+            next = []
+            for x in current:
+                for neighbor in x.neighbors:
+                    if neighbor not in map:
+                        neighbor_copy = UndirectedGraphNode(neighbor.label)
+                        next.append(neighbor)
+                        map[x].neighbors.append(neighbor_copy)
+                        map[neighbor] = neighbor_copy
+                    else:
+                        map[x].neighbors.append(map[neighbor])
+            current = next
+        return start

Insert Interval.py

@@ -0,0 +1,16 @@
+class Solution:
+    def insert(self, intervals, newInterval):
+        return self.merge(intervals + [newInterval])
+        
+    def merge(self, intervals):
+        if len(intervals) == 0:
+            return intervals
+        intervals.sort(key = lambda x: x.start)
+        result = [intervals[0]]
+        for i in range(1, len(intervals)):
+            current, prev = intervals[i], result[-1]
+            if current.start <= prev.end:
+                prev.end = max(prev.end, current.end)
+            else:
+                result.append(current)
+        return result

Merge Intervals.py

@@ -0,0 +1,13 @@
+class Solution:
+    def merge(self, intervals):
+        if len(intervals) == 0:
+            return intervals
+        intervals.sort(key = lambda x: x.start)
+        result = [intervals[0]]
+        for i in range(1, len(intervals)):
+            current, prev = intervals[i], result[-1]
+            if current.start <= prev.end:
+                prev.end = max(prev.end, current.end)
+            else:
+                result.append(current)
+        return result

Restore IP Addresses.py

@@ -0,0 +1,22 @@
+class Solution:
+    def restoreIpAddresses(self, s):
+        result = []
+        self.restoreIpAddressesRecur(result, s, "", 0)
+        return result
+        
+    def restoreIpAddressesRecur(self, result, s, current, dots):
+        # pruning to improve performance
+        if (4 - dots) * 3 < len(s):
+            return
+        if dots == 3:
+            if self.isValid(s):
+                result.append(current + s)
+        else:
+            for i in range(3):
+                if len(s) > i and self.isValid(s[:i + 1]):
+                    self.restoreIpAddressesRecur(result, s[i + 1:], current + s[:i + 1] + '.', dots + 1)
+        
+    def isValid(self, s):
+        if len(s) == 0 or (s[0] == "0" and s != "0"):
+            return False
+        return int(s) < 256

Simplify Path.py

@@ -0,0 +1,10 @@
+class Solution:
+    def simplifyPath(self, path):
+        stack, tokens = [], path.split('/')
+        for token in tokens:
+            if token == "..":
+                if len(stack) > 0:
+                    stack.pop()
+            elif token != "" and token != ".":
+                stack.append(token)
+        return "/" + reduce(lambda acc, x: acc + x + "/", stack, "")[:-1]

Word Search.py

@@ -0,0 +1,18 @@
+class Solution:
+    def exist(self, board, word):
+        visited = [[0 for y in range(len(board[0]))] for x in range(len(board))]
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if self.existRecur(board, word, visited, i, j) == True:
+                    return True
+        return False
+                
+    def existRecur(self, board, word, visited, i, j):
+        if len(word) == 0:
+            return True
+        if i >= len(board) or j >= len(board[0]) or i < 0 or j < 0 or visited[i][j] == 1 or board[i][j] != word[0]:
+            return False
+        visited[i][j] = 1
+        found = self.existRecur(board, word[1:], visited, i + 1, j) or self.existRecur(board, word[1:], visited, i - 1, j) or self.existRecur(board, word[1:], visited, i, j + 1) or self.existRecur(board, word[1:], visited, i, j - 1)
+        visited[i][j] = 0
+        return found

ZigZag Conversion.py

@@ -0,0 +1,13 @@
+class Solution:
+    def convert(self, s, nRows):
+        step, zigzag = 2 * nRows - 2, ""
+        if s == None or len(s) == 0 or nRows <= 0:
+            return ""
+        if nRows == 1:
+            return s
+        for i in range(nRows):
+            for j in range(i, len(s), step):
+                zigzag += s[j]
+                if i > 0 and i < nRows - 1 and j + step - 2 * i < len(s):
+                    zigzag += s[j + step - 2 * i]
+        return zigzag