add new solution

Author: DSXiangLi

script/[1035]不相交的线.py

@@ -0,0 +1,70 @@
+# 在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。 
+# 
+#  现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足： 
+# 
+#  
+#  nums1[i] == nums2[j] 
+#  且绘制的直线不与任何其他连线（非水平线）相交。 
+#  
+# 
+#  请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。 
+# 
+#  以这种方法绘制线条，并返回可以绘制的最大连线数。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：nums1 = [1,4,2], nums2 = [1,2,4]
+# 输出：2
+# 解释：可以画出两条不交叉的线，如上图所示。 
+# 但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相
+# 交。
+#  
+# 
+#  
+#  示例 2： 
+# 
+#  
+# 输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
+# 输出：3
+#  
+# 
+#  
+#  示例 3： 
+# 
+#  
+# 输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
+# 输出：2 
+# 
+#  
+#  
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= nums1.length, nums2.length <= 500 
+#  1 <= nums1[i], nums2[j] <= 2000 
+#  
+# 
+#  
+#  Related Topics 数组 动态规划 
+#  👍 346 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
+        l1 = len(nums1)
+        l2 = len(nums2)
+        dp = [[0] * (l2+1)for i in range(l1+1)]
+        for i in range(1,l1+1):
+            for j in range(1, l2+1):
+                if nums1[i-1]==nums2[j-1]:
+                    dp[i][j] = dp[i-1][j-1]+1
+                else:
+                    dp[i][j] = max(dp[i][j-1],dp[i-1][j],dp[i-1][j-1])
+        return dp[-1][-1]
+# leetcode submit region end(Prohibit modification and deletion)

script/[1049]最后一块石头的重量 II.py

@@ -0,0 +1,55 @@
+# 有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。 
+# 
+#  每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下： 
+# 
+#  
+#  如果 x == y，那么两块石头都会被完全粉碎； 
+#  如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。 
+#  
+# 
+#  最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：stones = [2,7,4,1,8,1]
+# 输出：1
+# 解释：
+# 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
+# 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
+# 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
+# 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：stones = [31,26,33,21,40]
+# 输出：5
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= stones.length <= 30 
+#  1 <= stones[i] <= 100 
+#  
+#  Related Topics 数组 动态规划 
+#  👍 499 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def lastStoneWeightII(self, stones: List[int]) -> int:
+        total = sum(stones)
+        l = total//2
+        dp = [0] * (l+1)
+        for s in stones:
+            for i in range(l, s-1, -1):
+                dp[i] = max(dp[i], dp[i-s]+s)
+        return total - 2* dp[-1]
+# leetcode submit region end(Prohibit modification and deletion)

script/[1143]最长公共子序列.py

@@ -0,0 +1,62 @@
+# 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。 
+# 
+#  一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 
+# 
+#  
+#  例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。 
+#  
+# 
+#  两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：text1 = "abcde", text2 = "ace" 
+# 输出：3  
+# 解释：最长公共子序列是 "ace" ，它的长度为 3 。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：text1 = "abc", text2 = "abc"
+# 输出：3
+# 解释：最长公共子序列是 "abc" ，它的长度为 3 。
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 输入：text1 = "abc", text2 = "def"
+# 输出：0
+# 解释：两个字符串没有公共子序列，返回 0 。
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= text1.length, text2.length <= 1000 
+#  text1 和 text2 仅由小写英文字符组成。 
+#  
+#  Related Topics 字符串 动态规划 
+#  👍 1065 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        l1 = len(text1)
+        l2 = len(text2)
+        dp = [[0] * (l2+1)for i in range(l1+1)]
+        for i in range(1,l1+1):
+            for j in range(1, l2+1):
+                if text1[i-1]==text2[j-1]:
+                    dp[i][j] = dp[i-1][j-1]+1
+                else:
+                    dp[i][j] = max(dp[i][j-1],dp[i-1][j],dp[i-1][j-1])
+        return dp[-1][-1]
+# leetcode submit region end(Prohibit modification and deletion)

script/[1155]掷骰子的N种方法.py

@@ -0,0 +1,49 @@
+# 这里有 n 个一样的骰子，每个骰子上都有 k 个面，分别标号为 1 到 k 。 
+# 
+#  给定三个整数 n , k 和 target ，返回可能的方式(从总共 kn 种方式中)滚动骰子的数量，使正面朝上的数字之和等于 target 。 
+# 
+#  答案可能很大，你需要对 109 + 7 取模 。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：n = 1, k = 6, target = 3
+# 输出：1
+# 解释：你扔一个有6张脸的骰子。
+# 得到3的和只有一种方法。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：n = 2, k = 6, target = 7
+# 输出：6
+# 解释：你扔两个骰子，每个骰子有6个面。
+# 得到7的和有6种方法1+6 2+5 3+4 4+3 5+2 6+1。
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 输入：n = 30, k = 30, target = 500
+# 输出：222616187
+# 解释：返回的结果必须是对 109 + 7 取模。 
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= n, k <= 30 
+#  1 <= target <= 1000 
+#  
+#  Related Topics 动态规划 
+#  👍 140 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def numRollsToTarget(self, n: int, k: int, target: int) -> int:
+# leetcode submit region end(Prohibit modification and deletion)

script/[115]不同的子序列.py

@@ -0,0 +1,61 @@
+# 给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。 
+# 
+#  字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列
+# ，而 "AEC" 不是） 
+# 
+#  题目数据保证答案符合 32 位带符号整数范围。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：s = "rabbbit", t = "rabbit"
+# 输出：3
+# 解释：
+# 如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
+# rabbbit
+# rabbbit
+# rabbbit 
+# 
+#  示例 2： 
+# 
+#  
+# 输入：s = "babgbag", t = "bag"
+# 输出：5
+# 解释：
+# 如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
+# babgbag
+# babgbag
+# babgbag
+# babgbag
+# babgbag
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  0 <= s.length, t.length <= 1000 
+#  s 和 t 由英文字母组成 
+#  
+#  Related Topics 字符串 动态规划 
+#  👍 823 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        ls = len(s)
+        lt = len(t)
+        dp = [[1] + [0] * lt for i in range(ls+1)] # t=''的时候出现1次
+        # dp[i][j]是前i个s里面有几个前j个t字符= 前i-1个s有多少个j-1个t+ 前i-个s有多少个j个t
+        for i in range(1, ls+1):
+            for j in range(1, lt+1):
+                if s[i-1]==t[j-1]:
+                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
+                else:
+                    dp[i][j] = dp[i-1][j]
+        return dp[-1][-1]
+# leetcode submit region end(Prohibit modification and deletion)

script/[139]单词拆分.py

@@ -0,0 +1,59 @@
+# 给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。 
+# 
+#  注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入: s = "leetcode", wordDict = ["leet", "code"]
+# 输出: true
+# 解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入: s = "applepenapple", wordDict = ["apple", "pen"]
+# 输出: true
+# 解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
+#      注意，你可以重复使用字典中的单词。
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
+# 输出: false
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= s.length <= 300 
+#  1 <= wordDict.length <= 1000 
+#  1 <= wordDict[i].length <= 20 
+#  s 和 wordDict[i] 仅有小写英文字母组成 
+#  wordDict 中的所有字符串 互不相同 
+#  
+#  Related Topics 字典树 记忆化搜索 哈希表 字符串 动态规划 
+#  👍 1725 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        ls = len(s)
+        dp = [False]* (ls+1)
+        dp[0]=True
+        wordDict = set(wordDict)
+        for i in range(1, ls+1):
+            for ss in wordDict:
+                lw = len(ss)
+                if i>=lw:
+                    dp[i] = dp[i] or (dp[i-lw] and s[(i-lw):i]==ss)
+        return dp[-1]
+# leetcode submit region end(Prohibit modification and deletion)