add more solutions

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

Maximal Rectangle.py

@@ -0,0 +1,27 @@
+class Solution:
+ def maximalRectangle(self, matrix):
+ heights = [[0 for j in range(len(matrix[0]))] for i in range(len(matrix))]
+ for i in range(0, len(matrix)):
+ for j in range(len(matrix[0])):
+ if matrix[i][j] == "0":
+ heights[i][j] = 0
+ elif i == 0:
+ heights[i][j] = 1
+ else:
+ heights[i][j] = int(heights[i - 1][j]) + 1
+ return reduce(lambda acc, i: max(acc, self.largestRectangleArea(heights[i])), range(len(heights)), 0)
+
+ # This is the solution for question Largest Rectangle in Histogram
+ 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

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

Permutation Sequence.py

@@ -0,0 +1,12 @@
+class Solution:
+ def getPermutation(self, n, k):
+ seq, k, fact = "", k - 1, math.factorial(n - 1)
+ perm = [i for i in range(1, n + 1)]
+ for i in reversed(range(n)):
+ curr = perm[k / fact]
+ seq += str(curr)
+ perm.remove(curr)
+ if i > 0:
+ k %= fact
+ fact /= i
+ return seq

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]

Sqrt(x).py

@@ -0,0 +1,10 @@
+class Solution:
+ def sqrt(self, x):
+ low, high = 0, x / 2 + 1
+ while high >= low:
+ mid = (high + low) / 2
+ if x < mid * mid:
+ high = mid - 1
+ else:
+ low = mid + 1
+ return int(high)

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