数组中等题

Author: princewen

sort_by_leetcode/dynamic programming/easy/121. Best Time to Buy and Sell Stock.py

@@ -0,0 +1,31 @@
+"""
+
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
+
+Example 1:
+Input: [7, 1, 5, 3, 6, 4]
+Output: 5
+
+max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
+Example 2:
+Input: [7, 6, 4, 3, 1]
+Output: 0
+
+In this case, no transaction is done, i.e. max profit = 0.
+
+"""
+"""使用53题的思路，两个变量"""
+
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        curSum=maxSum=0
+        for i in range(1,len(prices)):
+            curSum=max(0,curSum+prices[i]-prices[i-1])
+            maxSum = max(curSum,maxSum)
+        return maxSum

sort_by_leetcode/dynamic programming/easy/198. House Robber.py

@@ -0,0 +1,32 @@
+"""
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.
+
+Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.
+
+Credits:
+Special thanks to @ifanchu for adding this problem and creating all test cases. Also thanks to @ts for adding additional test cases.
+
+"""
+"""动态规划
+f(0) = nums[0]
+f(1) = max(num[0], num[1])
+f(k) = max( f(k-2) + nums[k], f(k-1) )
+
+"""
+
+class Solution(object):
+    def rob(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if not nums:
+            return 0
+        if len(nums) < 3:
+            return max(nums)
+        else:
+            nums[1] = max(nums[0],nums[1])
+            for i in range(2,len(nums)):
+                nums[i] = max(nums[i]+nums[i-2],nums[i-1])
+            return nums[-1]

sort_by_leetcode/dynamic programming/easy/303. Range Sum Query - Immutable.py

@@ -0,0 +1,43 @@
+"""
+
+Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.
+
+Example:
+Given nums = [-2, 0, 3, -5, 2, -1]
+
+sumRange(0, 2) -> 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
+Note:
+You may assume that the array does not change.
+There are many calls to sumRange function.
+
+
+"""
+
+"""正向思维，用一个数组保存从第一个数到每个位置的求和"""
+
+
+class NumArray(object):
+    def __init__(self, nums):
+        """
+        :type nums: List[int]
+        """
+        self.dp = nums
+        for i in range(1, len(nums)):
+            self.dp[i] += self.dp[i - 1]
+
+    def sumRange(self, i, j):
+        """
+        :type i: int
+        :type j: int
+        :rtype: int
+        """
+        return self.dp[j] - (self.dp[i - 1] if i > 0 else 0)
+
+
+
+
+        # Your NumArray object will be instantiated and called as such:
+        # obj = NumArray(nums)
+        # param_1 = obj.sumRange(i,j)

sort_by_leetcode/dynamic programming/easy/53. Maximum Subarray.py

@@ -0,0 +1,29 @@
+"""
+
+Find the contiguous subarray within an array (containing at least one number) which has the largest sum.
+
+For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
+the contiguous subarray [4,-1,2,1] has the largest sum = 6.
+
+click to show more practice.
+
+Subscribe to see which companies asked this question.
+
+"""
+
+"""要点：两个指针，一个指针记录当前的最大值a1，一个记录循环每个元素时的最大值a2
+a2的更新规则是，如果a2+当前元素比原来a2大，则更新a2=原a2+当前元素，否则a2=当前元素
+a1的更新规则是 a1 = a1 if a1 >a2 else a2
+"""
+
+class Solution(object):
+    def maxSubArray(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        curSum=maxSum=nums[0]
+        for i in range(1,len(nums)):
+            curSum = max(nums[i],curSum+nums[i])
+            maxSum = max(curSum,maxSum)
+        return maxSum

sort_by_leetcode/dynamic programming/easy/62. Unique Paths.py

@@ -0,0 +1,63 @@
+"""
+
+A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+
+
+
+"""
+
+"""利用数学方法"""
+
+
+class Solution(object):
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        if m > n:
+            m, n = m - 1, n - 1
+        else:
+            m, n = n - 1, m - 1
+        if m <= 0 or n <= 0:
+            return 1
+        t = m + n
+        sub = 1
+        for i in range(1, n):
+            t = t * (m + n - i)
+            sub = sub * (i + 1)
+
+        return t / sub
+
+"""利用动态规划的方法"""
+
+
+class Solution(object):
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        count = [[0 for t in range(n)] for x in range(m)]
+        count[0][0] = 1
+        for i in range(m):
+            for j in range(n):
+                if i == 0 and j == 0:
+                    count[i][j] = 1
+                elif i == 0:
+                    count[i][j] = count[i][j - 1]
+                elif j == 0:
+                    count[i][j] = count[i - 1][j]
+                else:
+                    count[i][j] = count[i - 1][j] + count[i][j - 1]
+        return count[m - 1][n - 1]
+
+
+

sort_by_leetcode/dynamic programming/easy/63. Unique Paths II.py

@@ -0,0 +1,45 @@
+"""
+
+Follow up for "Unique Paths":
+
+Now consider if some obstacles are added to the grids. How many unique paths would there be?
+
+An obstacle and empty space is marked as 1 and 0 respectively in the grid.
+
+For example,
+There is one obstacle in the middle of a 3x3 grid as illustrated below.
+
+[
+  [0,0,0],
+  [0,1,0],
+  [0,0,0]
+]
+The total number of unique paths is 2.
+
+Note: m and n will be at most 100.
+
+"""
+"""与62题相似，不过多了一个条件"""
+
+
+class Solution(object):
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        """
+        :type obstacleGrid: List[List[int]]
+        :rtype: int
+        """
+        if not obstacleGrid:
+            return 0
+        for i in range(len(obstacleGrid)):
+            for j in range(len(obstacleGrid[0])):
+                if obstacleGrid[i][j] == 1:
+                    obstacleGrid[i][j] = 0
+                elif i == 0 and j == 0:
+                    obstacleGrid[i][j] = 1
+                elif i == 0:
+                    obstacleGrid[i][j] = obstacleGrid[i][j - 1]
+                elif j == 0:
+                    obstacleGrid[i][j] = obstacleGrid[i - 1][j]
+                else:
+                    obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1]
+        return obstacleGrid[i][j]

sort_by_leetcode/dynamic programming/easy/64. Minimum Path Sum.py

@@ -0,0 +1,25 @@
+"""
+
+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.
+
+"""
+"""仍然是和62题一样的思路"""
+class Solution(object):
+    def minPathSum(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        for i in range(len(grid)-1,-1,-1):
+            for j in range(len(grid[0])-1,-1,-1):
+                if j == len(grid[0])-1 and i== len(grid)-1:
+                    continue
+                elif j == len(grid[0])-1:
+                    grid[i][j] = grid[i+1][j] + grid[i][j]
+                elif i == len(grid)-1:
+                    grid[i][j] = grid[i][j] + grid[i][j+1]
+                else:
+                    grid[i][j] = grid[i][j] + min(grid[i+1][j],grid[i][j+1])
+        return grid[0][0]

sort_by_leetcode/dynamic programming/easy/70. Climbing Stairs.py

@@ -0,0 +1,21 @@
+"""
+
+You are climbing a stair case. It takes n steps to reach to the top.
+
+Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+Note: Given n will be a positive integer.
+
+"""
+"""动态规划的思路，详细解释参照文章开头给出的公众号帖子"""
+class Solution(object):
+    def climbStairs(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        a = 1
+        b = 1
+        for i in range(2,n+1):
+            a,b = b,a+b
+        return b

sort_by_leetcode/tree/easy/100. Same Tree.py

@@ -0,0 +1,29 @@
+"""
+
+Given two binary trees, write a function to check if they are equal or not.
+
+Two binary trees are considered equal if they are structurally identical and the nodes have the same value.
+
+"""
+"""递归的判断两个数是否相等，并判断两棵树时候同时为空，即结构是否相等"""
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSameTree(self, p, q):
+        """
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: bool
+        """
+        if p and q:
+            if p.val == q.val and self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right):
+                return True
+            else:
+                return False
+        return p is q

sort_by_leetcode/tree/easy/104. Maximum Depth of Binary Tree.py

@@ -0,0 +1,27 @@
+"""
+
+Given a binary tree, find its maximum depth.
+
+The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+"""
+"""递归方式"""
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        left = self.maxDepth(root.left)+1
+        right = self.maxDepth(root.right)+1
+        return max(left,right)