update

Author: jasoncao11

61. 乘积最大子数组.md

@@ -0,0 +1,28 @@
+***给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。***
+
+```
+输入: nums = [2,3,-2,4]
+输出: 6
+解释: 子数组 [2,3] 有最大乘积 6。
+```
+
+```
+class Solution(object):
+    def maxProduct(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        #由于存在负数，那么会导致最大的变最小的，最小的变最大的，因此需要维护 dp_max[i] 即以位置 i 结尾的当前最大乘积， dp_min[i] 以位置 i 结尾的当前最小乘积。
+        n = len(nums)
+        dp_max = [0]*n
+        dp_min = [0]*n
+        dp_max[0] = nums[0]
+        dp_min[0] = nums[0]
+        res = max(dp_max[0], dp_min[0])
+        for i in range(1,n):
+            dp_max[i] = max(nums[i], dp_max[i-1]*nums[i], dp_min[i-1]*nums[i])
+            dp_min[i] = min(nums[i], dp_min[i-1]*nums[i], dp_max[i-1]*nums[i])
+            res = max(res, dp_max[i], dp_min[i])
+        return res
+```

62. 最长递增子序列.md

@@ -0,0 +1,20 @@
+***给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。***
+
+```
+输入：nums = [10,9,2,5,3,7,101,18]
+输出：4
+解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
+```
+
+```
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        #dp[i]表示以nums[i]结尾的上升子序列的长度，nums[i]必须被选取，且必须为这个子序列的最后一个元素。
+        n = len(nums)
+        dp = [1]*n
+        for i in range(1, n):
+            for j in range(i):
+                if nums[j] < nums[i]:
+                    dp[i] = max(dp[j]+1, dp[i])
+        return max(dp)
+```

63. 单词拆分.md

@@ -0,0 +1,24 @@
+***给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。***
+
+```
+输入: s = "leetcode", wordDict = ["leet", "code"]
+输出: true
+解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
+```
+
+```
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        #dp[i]表示s[:i+1]是否可以用wordDict中的单词表示
+        s = ' '+s
+        n = len(s)
+        dp = [False] *(n)
+        dp[0] = True
+        for i in range(1, n):
+            for j in range(i+1, n+1):
+                if dp[i-1] and s[i:j] in wordDict:
+                    dp[j-1] = True
+                    if dp[-1] == True:
+                        return True
+        return False
+```

64. 目标和.md

@@ -0,0 +1,44 @@
+***给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。***
+
+```
+原问题等同于： 找到nums一个正子集和一个负子集，使得总和等于target
+我们假设P是正子集，N是负子集 例如： 假设nums = [1, 2, 3, 4, 5]，target = 3，一个可能的解决方案是+1-2+3-4+5 = 3 这里正子集P = [1, 3, 5]和负子集N = [2, 4]
+那么让我们看看如何将其转换为子集求和问题：
+sum(P) - sum(N) = target
+sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
+2 * sum(P) = target + sum(nums)
+因此，原来的问题已转化为一个求子集的和问题： 找到nums的一个子集 P，使得sum(P) = (target + sum(nums)) / 2
+请注意，上面的公式已经证明target + sum(nums)必须是偶数，否则输出为0
+
+dp[ i ][ j ]定义为从数组nums中 0 - i 的元素进行取舍可以得到 j 的方法数量
+```
+
+```
+class Solution(object):
+    def findTargetSumWays(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        sumAll = sum(nums)
+        if target > sumAll or (target + sumAll) % 2:
+            return 0
+        target = (target + sumAll) // 2
+
+        dp = [[0]*(target+1) for _ in range(len(nums))]
+        dp[0][0] = 2 if nums[0] == 0 else 1
+
+        for j in range(1, target+1):
+            if j==nums[0]:
+                dp[0][j] = 1
+        
+
+        for i in range(1, len(nums)):
+            for j in range(target+1):
+                if j-nums[i] >= 0:
+                    dp[i][j] = dp[i-1][j]+dp[i-1][j-nums[i]]
+                else:
+                    dp[i][j] = dp[i-1][j]
+        return dp[-1][-1]
+```

65. 完全平方数.md

@@ -0,0 +1,15 @@
+***给你一个整数 n ，返回和为 n 的完全平方数的最少数量。***
+
+```
+class Solution:
+    def numSquares(self, n: int) -> int:
+        #dp[i]代表和为 i 的完全平方数的最少数量
+        dp = [0]*(n+1)
+        for i in range(1, n+1):
+            dp[i] = i 
+            j = 1
+            while i-j*j >= 0:
+                dp[i] = min(dp[i], dp[i-j*j]+1)
+                j += 1
+        return dp[n]
+```