Adding solution of 64, 72, 85 problems

Author: Garvit244

64.py

@@ -0,0 +1,30 @@
+'''
+	Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
+
+	Note: You can only move either down or right at any point in time.
+'''
+class Solution(object):
+    def minPathSum(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        if not grid:
+        	return 0
+
+        row, col = len(grid), len(grid[0])
+        dp = [[0 for _ in range(col)] for _ in range(row)]
+        dp[0][0] = grid[0][0]
+
+        for index in range(1, row):
+        	dp[index][0] = dp[index-1][0] + grid[index][0]
+
+        for index in range(1, col):
+        	dp[0][index] = dp[0][index-1] + grid[0][index]
+
+        print dp
+        for index_i in range(1, row):
+        	for index_j in range(1, col):
+        		dp[index_i][index_j] = min(dp[index_i-1][index_j], dp[index_i][index_j-1]) + grid[index_i][index_j]
+
+        return dp[row-1][col-1]

72.py

@@ -0,0 +1,50 @@
+'''
+	Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
+
+	You have the following 3 operations permitted on a word:
+
+	Insert a character
+	Delete a character
+	Replace a character
+	Example 1:
+
+	Input: word1 = "horse", word2 = "ros"
+	Output: 3
+	Explanation: 
+	horse -> rorse (replace 'h' with 'r')
+	rorse -> rose (remove 'r')
+	rose -> ros (remove 'e')
+	Example 2:
+
+	Input: word1 = "intention", word2 = "execution"
+	Output: 5
+	Explanation: 
+	intention -> inention (remove 't')
+	inention -> enention (replace 'i' with 'e')
+	enention -> exention (replace 'n' with 'x')
+	exention -> exection (replace 'n' with 'c')
+	exection -> execution (insert 'u')
+'''
+
+class Solution(object):
+    def minDistance(self, word1, word2):
+        """
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        m , n = len(word1), len(word2)
+
+        dp = [[0 for _ in range(n+1)] for _ in range(m+1)]
+        for index_i in range(m+1):
+        	for index_j in range(n+1):
+        		if index_i == 0:
+        			dp[index_i][index_j] = index_j
+        		elif index_j == 0:
+        			dp[index_i][index_j] = index_i
+        		elif word1[index_i-1] == word2[index_j-1]:
+        			dp[index_i][index_j] = dp[index_i-1][index_j-1]
+        		else:
+        			dp[index_i][index_j] = 1 + min(dp[index_i-1][index_j], dp[index_i-1][index_j-1], dp[index_i][index_j-1])
+
+        return dp[m][n]

85.py

@@ -0,0 +1,69 @@
+'''
+	Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.
+
+	Example:
+
+	Input:
+	[
+	  ["1","0","1","0","0"],
+	  ["1","0","1","1","1"],
+	  ["1","1","1","1","1"],
+	  ["1","0","0","1","0"]
+	]
+	Output: 6
+'''
+
+class Solution(object):
+    def largestRectangleArea(self, heights):
+        """
+        :type heights: List[int]
+        :rtype: int
+        """
+        if not heights:
+        	return 0
+
+        stack = []
+        result, index = 0, 0
+
+        while index < len(heights):
+        	if not stack or heights[index] >= heights[stack[-1]]:
+        		stack.append(index)
+        		index += 1
+        	else:
+        		curr = stack.pop()
+        		if not stack:
+        			area = heights[curr]*index
+        		else:
+        			area = heights[curr] * (index-stack[-1]-1)
+        		result = max(result, area)
+
+        while stack:
+        	curr = stack.pop()
+        	if not stack:
+        		area = heights[curr]*index
+        	else:
+        		area = heights[curr] * (index-stack[-1]-1)
+        	result = max(result, area)
+        return result
+
+    def maximalRectangle(self, matrix):
+        """
+        :type matrix: List[List[str]]
+        :rtype: int
+        """
+        if not matrix:
+            return 0
+        m, n = len(matrix), len(matrix[0])
+        heights = [0 for index in range(n)]
+        result = 0
+        
+        for index_i in range(m):
+            for index_j in range(n):
+                if matrix[index_i][index_j] != '0':
+                    heights[index_j] = heights[index_j] + 1
+                else:
+                    heights[index_j] = 0
+                    
+            result = max(result, self.largestRectangleArea(heights))
+        return result
+