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

Decode Ways.py

@@ -0,0 +1,13 @@
+class Solution:
+    def numDecodings(self, s):
+        if len(s) == 0:
+            return 0
+        prev, prev_prev = 1, 0
+        for i in range(len(s)):
+            current = 0
+            if s[i] != '0':
+                current = prev
+            if i > 0 and (s[i - 1] == "1" or (s[i - 1] == "2" and s[i] <= "6")):
+                current += prev_prev
+            prev, prev_prev = current, prev
+        return prev

Distinct Subsequences.py

@@ -0,0 +1,11 @@
+class Solution:
+    def numDistinct(self, S, T):
+        ways = [[0 for j in range(len(S) + 1)] for i in range(len(T) + 1)]
+        for i in range(len(S) + 1):
+            ways[0][i] = 1
+        for i in range(1, len(T) + 1):
+            for j in range(1, len(S) + 1):
+                ways[i][j] = ways[i][j - 1]
+                if T[i - 1] == S[j - 1]:
+                    ways[i][j] += ways[i - 1][j - 1]
+        return ways[len(T)][len(S)]

Gas Station.py

@@ -0,0 +1,14 @@
+class Solution:
+    def canCompleteCircuit(self, gas, cost):
+        start, sum_so_far, sum = 0, 0, 0
+        for i in range(len(gas)):
+            diff = gas[i] - cost[i]
+            if sum_so_far + diff < 0:
+                start = i + 1
+                sum_so_far = 0
+            else:
+                sum_so_far += diff
+            sum += diff
+        if sum >= 0:
+            return start
+        return -1

Implement strStr().py

@@ -0,0 +1,11 @@
+class Solution:
+    def strStr(self, haystack, needle):
+        for i in range(len(haystack) - len(needle) + 1):
+            found = True
+            for j in range(len(needle)):
+                if haystack[i + j] != needle[j]:
+                    found = False
+                    break
+            if found:
+                return haystack[i:]
+        return None

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

Largest Rectangle in Histogram.py

@@ -0,0 +1,14 @@
+class Solution:
+    def largestRectangleArea(self, height):
+        increasing, area, i = [], 0, 0
+        while i <= len(height):
+            if len(increasing) == 0 or (i < len(height) and height[i] > height[increasing[-1]]):
+                increasing.append(i)
+                i += 1
+            else:
+                last = increasing.pop()
+                if len(increasing) == 0:
+                    area = max(area, height[last] * i)
+                else:
+                    area = max(area, height[last] * (i - increasing[-1] - 1))
+        return area

Longest Substring Without Repeating Characters.py

@@ -0,0 +1,14 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s):
+        count, start, longest = [False for i in range(256)], 0, 0
+        for i in range(len(s)):
+            if count[ord(s[i])] == False:
+                count[ord(s[i])] = True
+            else:
+                longest = max(i - start, longest)
+                while s[start] != s[i]:
+                    count[ord(s[start])] = False
+                    start += 1
+                start += 1
+        longest = max(len(s) - start, longest)
+        return longest

Longest Valid Parentheses.py

@@ -0,0 +1,15 @@
+class Solution:
+    def longestValidParentheses(self, s):
+        longest, last, indices = 0, 0, []
+        for i in range(len(s)):
+            if s[i] == '(':
+                indices.append(i)
+            elif len(indices) == 0:
+                last = i + 1
+            else:
+                index = indices.pop()
+                if len(indices) == 0:
+                    longest = max(longest, i - last + 1)
+                else:
+                    longest = max(longest, i - indices[-1])
+        return longest