国产精品久久久久久妇女6080 ,美女网站久久,1000部国产精品成人观看

[LeetCode]576. Out of Boundary Paths (Medium) Python-2024.01.26

Uriel — Fri, 26 Jan 2024 11:58:00 GMT

�l�出二维grid的长度高度m宽度n�Q�和初始球在的位�|?startRow, startColumn)�Q�问�l�过最多maxMove步，每次可以�U�d��球到上下左右七种一��|��有几�U�方式出界，DP
用一个��时变量t保存上一轮dp的状态，可以节省�I�间

#576
#Runtime: 118 ms (Beats 39.13%)
#Memory: 11.7 MB (Beats 100%)

class Solution(object):
    def findPaths(self, m, n, maxMove, startRow, startColumn):
        """
        :type m: int
        :type n: int
        :type maxMove: int
        :type startRow: int
        :type startColumn: int
        :rtype: int
        """
        MOD = 10**9+7
        dp = [[0] * n for _ in xrange(m)]
        dp[startRow][startColumn] = 1
        cnt = 0
        for _ in xrange(1, maxMove + 1):
            t = [[0] * n for _ in xrange(m)]
            for i in xrange(m):
                for j in xrange(n):
                    if i == m - 1:
                        cnt = (cnt + dp[i][j]) % MOD
                    if j == n - 1:
                        cnt = (cnt + dp[i][j]) % MOD
                    if i == 0:
                        cnt = (cnt + dp[i][j]) % MOD
                    if j == 0:
                        cnt = (cnt + dp[i][j]) % MOD
                    t[i][j] = ((dp[i - 1][j] if i > 0 else 0) % MOD + (dp[i + 1][j] if i < m - 1 else 0) % MOD + (dp[i][j - 1] if j > 0 else 0) % MOD + (dp[i][j + 1] if j < n - 1 else 0) % MOD) % MOD
            dp = t
        return cnt

Uriel 2024-01-26 19:58 发表评论

[LeetCode]91. Decode Ways (Medium) Python-2023.12.25

Uriel — Mon, 25 Dec 2023 15:04:00 GMT

�l�出一列数�Q�按照A-Z对应1-26�Q�问�q�列数有几种拆分成字�W�串的方式，DP�Q�只要考虑当前�?-9以及最�q�两位数10-26的情�?br />

1 #91
2 #Runtime: 22 ms (Beats 17.34%)
3 #Memory: 13.4 MB (Beats 71.65%)
4
5 class Solution(object):
6     def numDecodings(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         dp = [0] * (len(s) + 1)
12         dp[0] = 1
13         for i in xrange(0, len(s)):
14             if i == 0:
15                 if s[i] == '0':
16                     return 0
17                 dp[i + 1] = 1
18             else:
19                 if 10 <= int(s[i - 1 : i + 1]) <= 26:
20                     dp[i + 1] += dp[i - 1]
21                 if 1 <= int(s[i]) <= 9:
22                     dp[i + 1] += dp[i]
23         return dp[-1]

Uriel 2023-12-25 23:04 发表评论

[LeetCode]1220. Count Vowels Permutation (Hard) Python-2023.10.28

Uriel — Tue, 31 Oct 2023 09:20:00 GMT

由a,e,i,o,u构成字符�Ԍ��要求�Q?/p>

- a -> e, i and u

- e -> a and i

- i -> e and o

- o -> i

- u -> i and o

问长�?span style="font-variant-numeric: normal; font-variant-east-asian: normal; font-variant-alternates: normal; font-kerning: auto; font-optical-sizing: auto; font-feature-settings: normal; font-variation-settings: normal; font-variant-position: normal; font-stretch: normal; line-height: normal; font-family: "Helvetica Neue";">n的字�W�串有几�U�构成方式，DP

1 #1220
2 #Runtime 142 ms Beats 77.78%
3 #Memory 17.8 MB Beats 55.56%
4
5 class Solution(object):
6     def countVowelPermutation(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         dp = [[1] * 5] + [[0] * 5 for _ in range(n - 1)]
12         MOD = 10**9 + 7
13         for i in xrange(1, n):
14             dp[i][0] = (dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][4]) % MOD
15             dp[i][1] = (dp[i - 1][0] + dp[i - 1][2]) % MOD
16             dp[i][2] = (dp[i - 1][1] + dp[i - 1][3]) % MOD
17             dp[i][3] = (dp[i - 1][2]) % MOD
18             dp[i][4] = (dp[i - 1][2] + dp[i - 1][3]) % MOD
19         return sum(dp[-1]) % MOD

Uriel 2023-10-31 17:20 发表评论

[LeetCode]2742. Painting the Walls (Hard) Python-2023.10.14

Uriel — Tue, 17 Oct 2023 13:57:00 GMT

�l�出找付费工人刷每一面墙需要的paint旉��time[i]和花费cost[i]�Q�如果付费工��在工作中�Q�可以��用另一名免费工人，免费工�h刷一面墙需�?旉��Q?��p��Q�问刷完n面墙的最��花费，背包问题

1 #2742
2 #Runtime: 858 ms (Beats 33.33%)
3 #Memory: 13.3 MB (Beats 33.33%)
4
5 class Solution(object):
6     def paintWalls(self, cost, time):
7         """
8         :type cost: List[int]
9         :type time: List[int]
10         :rtype: int
11         """
12         n = len(cost)
13         dp = [0] + [float('inf')] * n
14         for i in xrange(n):
15             for j in range(n, 0, -1):
16                 dp[j] = min(dp[j], dp[max(0, j - time[i] - 1)] + cost[i])
17         return dp[n]

Uriel 2023-10-17 21:57 发表评论

[LeetCode]2742. Painting the Walls (Hard) Python-2023.10.14

Uriel — Sat, 14 Oct 2023 09:27:00 GMT

Uriel 2023-10-14 17:27 发表评论

[LeetCode]746. Min Cost Climbing Stairs (Easy) Python-2023.10.13

Uriel — Fri, 13 Oct 2023 15:19:00 GMT

每次可以爬一�U�或者两�U�台�Ӟ��每��台阶有对应的cost�Q�从�W?�U�或者第1�U�台阶开始，问爬完台阶的最��花费，��单DP

1 #746
2 #Runtime: 33 ms (Beats 67.69%)
3 #Memory: 13.5 MB (Beats 32.59%)
4
5 class Solution(object):
6     def minCostClimbingStairs(self, cost):
7         """
8         :type cost: List[int]
9         :rtype: int
10         """
11         dp = [0] * (1 + len(cost))
12         for i in range(2, len(cost) + 1):
13             dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
14         return dp[-1]

Uriel 2023-10-13 23:19 发表评论

[LeetCode]1458. Max Dot Product of Two Subsequences (Hard) Python-2023.10.08

Uriel — Sun, 08 Oct 2023 16:25:00 GMT

�l�出两个数组nums1和nums2�Q�分别从他们之中取出�{�长的子数列做点乘，求可以获得的最大��|��DP

1 #1458
2 #Runtime: 198 ms (Beats 50%)
3 #Memory: 15.7 MB (Beats 75%)
4
5 class Solution(object):
6     def maxDotProduct(self, nums1, nums2):
7         """
8         :type nums1: List[int]
9         :type nums2: List[int]
10         :rtype: int
11         """
12         n = len(nums1)
13         m = len(nums2)
14         dp = [[float('-inf')] * (m + 1) for _ in range(n + 1)]
15         for i in range(1, n + 1):
16             for j in range(1, m + 1):
17                 dp[i][j] = max(nums1[i - 1] * nums2[j - 1], dp[i - 1][j - 1] + nums1[i - 1]* nums2[j - 1], dp[i - 1][j], dp[i][j - 1])
18         return dp[n][m]

Uriel 2023-10-09 00:25 发表评论

[LeetCode]799. Champagne Tower (Medium) Python-2023.09.24

Uriel — Sun, 24 Sep 2023 08:53:00 GMT

有query_row层垒��h��的玻璃杯�Q�第i层有i个杯子，从第一层开始倒水�Q�倒进去poured杯水�Q�求问第query_row层第query_glass个杯子有多少�?br />按层往下算�Q�每�ơ减��d��前杯子装�q�的1杯，剩下对半分入下一层相��M��个杯�?br />

1 #799
2 #Runtime: 59 ms (Beats 62.50%)
3 #Memory: 13.3 MB (Beats 45.11%)
4
5 class Solution(object):
6     def champagneTower(self, poured, query_row, query_glass):
7         """
8         :type poured: int
9         :type query_row: int
10         :type query_glass: int
11         :rtype: float
12         """
13         dp = [[0 for _ in range(x)] for x in range(1, query_row + 2)]
14         dp[0][0] = poured
15         for i in range(query_row):
16             for j in range(len(dp[i])):
17                 tp = (dp[i][j] - 1) / 2.0
18                 if tp > 0:
19                     dp[i + 1][j] += tp
20                     dp[i + 1][j + 1] += tp
21         return dp[query_row][query_glass] if dp[query_row][query_glass] <= 1 else 1

Uriel 2023-09-24 16:53 发表评论

[LeetCode]1048. Longest String Chain (Medium) Python-2023.09.23

Uriel — Sat, 23 Sep 2023 11:04:00 GMT

�l�出一堆单词，从中选出若干�Q�若要求每个单词由前一个单词在某个位置增加一个字�W�组成，问最多可以选出几个单词�Q�DP�Q�先�Ҏ��有单词按长度排名�Q�枚丑֍�词w�Q�dp[w]=dp[pre]+1�Q�若单词w由pre加一个字母组�?br />

1 #1048
2 #Runtime: 77 ms (Beats 90.91%)
3 #Memory: 13.5 MB (Beats 92.31%)
4
5 class Solution(object):
6     def longestStrChain(self, words):
7         """
8         :type words: List[str]
9         :rtype: int
10         """
11         dp = {}
12         ans = 1
13         for w in sorted(words, key=len):
14             dp[w] = 1
15             for i in range(len(w)):
16                 pre = w[ : i] + w[i + 1 :]
17                 if pre in dp:
18                     dp[w] = max(dp[w], dp[pre] + 1)
19                     ans = max(ans, dp[w])
20         return ans

Uriel 2023-09-23 19:04 发表评论

[LeetCode]377. Combination Sum IV (Medium) Python-2023.09.09

Uriel — Sat, 09 Sep 2023 09:12:00 GMT

求问用数�l�nums里面的数字凑成相加之和�ؓtarget的方式有多少�U�（不同��序��不同方法，每个数字可以无限�ơ数用）�Q�DP

1 #377
2 #Runtime: 22 ms (Beats 67.7%)
3 #Memory: 13.4 MB (Beats 38.41%)
4
5 class Solution(object):
6     def combinationSum4(self, nums, target):
7         """
8         :type nums: List[int]
9         :type target: int
10         :rtype: int
11         """
12         dp = [0] * (target + 1)
13         dp[0] = 1
14         for i in range(1, target + 1):
15             for x in nums:
16                 if i - x >= 0:
17                     dp[i] += dp[i - x]
18         return dp[target]

Uriel 2023-09-09 17:12 发表评论

[LeetCode]62. Unique Paths (Medium) Python-2023.09.03

Uriel — Sun, 03 Sep 2023 08:31:00 GMT

从二�l�格点左上角(1,1)开始每�ơ可以向右or向下赎ͼ�问走�?m,n)一共几�U�走法，��单DP�Q�dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

python2版：

1 #62
2 #Runtime: 10 ms (Beats 90.77%)
3 #Memory: 13.3 MB (Beats 30.67%)
4
5 class Solution(object):
6     def uniquePaths(self, m, n):
7         """
8         :type m: int
9         :type n: int
10         :rtype: int
11         """
12         dp = [[0] * n for _ in range(m)]
13         for i in range(0, m):
14             for j in range(0, n):
15                 if i == 0 or j == 0:
16                     dp[i][j] = 1
17                 else:
18                     dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
19         return dp[-1][-1]

python3版，递归+lru_cache

 1 #62
 2 #Runtime: 48 ms (Beats 23.61%)
 3 #Memory: 16.5 MB (Beats 11.21%)
 4 
 5 class Solution:
 6     def uniquePaths(self, m: int, n: int) -> int:
 7         @lru_cache(None)
 8         def dp(i, j):
 9             if i == 1 or j == 1:
10                 return 1
11             return dp(i - 1, j) + dp(i, j - 1)
12         return dp(m, n)

Uriel 2023-09-03 16:31 发表评论

[LeetCode]1326. Minimum Number of Taps to Open to Water a Garden (Hard) Python-2023.08.31

Uriel — Thu, 31 Aug 2023 11:09:00 GMT

�l�出一堆range��|��ranges[i]表示�W�i个tap可以覆盖[i-ranges[i], i+ranges[i]]�Q�问最��几个tap可以覆盖[0, n]�Q�如果不存在输出-1�Q�O(n*m)dp

1 #1326
2 #Runtime: 467 ms (Beats 26.32%)
3 #Memory: 13.6 MB (Beats 94.74%)
4
5 class Solution(object):
6     def minTaps(self, n, ranges):
7         """
8         :type n: int
9         :type ranges: List[int]
10         :rtype: int
11         """
12         dp = [0] + [n + 2] * n
13         for i, x in enumerate(ranges):
14             for j in range(max(i - x + 1, 0), min(i + x, n) + 1):
15                 dp[j] = min(dp[j], dp[max(0, i - x)] + 1)
16         return dp[n] if dp[n] < n + 2 else -1

Uriel 2023-08-31 19:09 发表评论

[LeetCode]403. Frog Jump (Hard) Python-2023.08.27

Uriel — Sun, 27 Aug 2023 08:33:00 GMT

�l�出一堆数字stones代表stones[i]处有矛_��Q�青蛙从�W�一个石子处出发�Q�第一�ơ必��蟩1步，之后每次可以跳的步数为k-1~k+1�Q�k为前一步蟩的步敎ͼ�问是否可达最后一个石子�?br />O(n^2)的dp�Q�用dict存储stones位置�Q�dict的value��到这个位�|�所有可能的上一步的长度�Q�参考了Discussion -> https://leetcode.com/problems/frog-jump/solutions/3964842/python3-solution/

1 #403
2 #Runtime: 191 ms (Beats 50.94%)
3 #Memory: 14.9 MB (Beats 79.25%)
4
5 class Solution(object):
6     def canCross(self, stones):
7         """
8         :type stones: List[int]
9         :rtype: bool
10         """
11         n = len(stones)
12         dp = {stone:set() for stone in stones}
13         dp[0].add(0)
14         for i in range(n):
15             for j in dp[stones[i]]:
16                 for d in range(j - 1, j + 2):
17                     if d and stones[i] + d in dp:
18                         dp[stones[i] + d].add(d)
19         return len(dp[stones[-1]]) > 0

Uriel 2023-08-27 16:33 发表评论

[LeetCode]646. Maximum Length of Pair Chain (Medium) Python-2023.08.26

Uriel — Sat, 26 Aug 2023 11:46:00 GMT

�l�出一堆数字pair�Q�pairs[i] = [left_i, right_i] and left_i < right_i�Q�找出最长的一列pair�Q��得每一个pair的right��于下一个pair的left�Q�pair的顺序可以打乱）�Q�DP
先将所有pair按right从小到大排序�Q�然后O(n^2)的DP

1 #646
2 #Runtime: 1406 ms (Beats 41.4%)
3 #Memory: 13.8 MB (Beats 67.91%)
4
5 class Solution(object):
6     def findLongestChain(self, pairs):
7         """
8         :type pairs: List[List[int]]
9         :rtype: int
10         """
11         pairs.sort(key=lambda x: x[1])
12         dp = [1] * len(pairs)
13         for i in range(1, len(pairs)):
14             for j in range(i):
15                 if pairs[i][0] > pairs[j][1]:
16                     dp[i] = max(dp[i], dp[j] + 1)
17         return max(dp)

Uriel 2023-08-26 19:46 发表评论

[LeetCode]97. Interleaving String (Medium) C++/Python-2014.01.20/2023.08.25

Uriel — Fri, 25 Aug 2023 11:51:00 GMT

判断字符串s3是否能由两个字符串s1和s2切分拼成�Q�复杂度O(nm)�Q�空间复杂度O(m)的写法参考了Discussion

https://leetcode.com/problems/interleaving-string/solutions/31885/python-dp-solutions-o-m-n-o-n-space-bfs-dfs/

C++版，复杂度O(nm)�Q�空间复杂度O(nm)

1 //97
2 //Runtime: 380 ms (Beats 5.2%)
3
4 class Solution {
5 public:
6     int dp[1010][1010];
7
8     bool isInterleave(string s1, string s2, string s3) {
9         if(!s1.length()) return s2 == s3;
10         if(!s2.length()) return s1 == s3;
11         int len = s3.length();
12         if(len != s1.length() + s2.length()) return false;
13         memset(dp, 0, sizeof(dp));
14         dp[0][0] = 1;
15         for(int i = 1; i <= len; ++i) {
16             for(int j = 0; j <= i && j <= s1.length(); ++j) {
17                 if(j >= 1 && s1[j - 1] == s3[i - 1] && dp[i - 1][j - 1]) {
18                     dp[i][j] = 1;
19                 }
20                 else if(j >= 0 && j < i && (i - j - 1) < s2.length() && s2[i - j - 1] == s3[i - 1] && dp[i - 1][j]) {
21                     dp[i][j] = 1;
22                 }
23                 if(i == len && dp[i][j]) return true;
24             }
25         }
26         return false;
27     }
28 };

Python版，复杂度O(nm)�Q�空间复杂度O(m)�Q�用xrange�I�间和时间cost更小�Q?br />

1 #97
2 #Runtime: 18 ms (Beats 91.39%)
3 #Memory: 13.3 MB (Beats 82.78%)
4
5 class Solution(object):
6     def isInterleave(self, s1, s2, s3):
7         """
8         :type s1: str
9         :type s2: str
10         :type s3: str
11         :rtype: bool
12         """
13         n, m, l = len(s1), len(s2), len(s3)
14         if n + m != l:
15             return False
16         dp = [True for _ in range(m + 1)]
17         for i in xrange(1, m + 1):
18             dp[i] = dp[i - 1] and s2[i - 1] == s3[i - 1]
19         for i in xrange(1, n + 1):
20             dp[0] = dp[0] and s1[i - 1] == s3[i - 1]
21             for j in xrange(1, m + 1):
22                 dp[j] = (dp[j] and s1[i - 1] == s3[i + j - 1]) or (dp[j - 1] and s2[j - 1] == s3[i + j - 1])
23         return dp[-1]

Uriel 2023-08-25 19:51 发表评论

[LeetCode]2369. Check if There is a Valid Partition For The Array (Medium) Python-2023.08.13

Uriel — Sun, 13 Aug 2023 08:42:00 GMT

一列数字，求问是否可以切割成若�q�片�Q��得每一片满��以下之一�Q?br />

1.The subarray consists of exactly 2 equal elements. For example, the subarray [2,2] is good.

2.The subarray consists of exactly 3 equal elements. For example, the subarray [4,4,4] is good.

3.The subarray consists of exactly 3 consecutive increasing elements, that is, the difference between adjacent elements is 1. For example, the subarray [3,4,5] is good, but the subarray [1,3,5] is not.

DP

1 #2369
2 #Runtime: 817 ms (Beats 85.71%)
3 #Memory: 26.2 MB (Beats 100%)
4
5 class Solution(object):
6     def validPartition(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: bool
10         """
11         dp = [0] * (len(nums) + 1)
12         dp[0] = 1
13         for i in range(1, len(nums)):
14             if i == 1:
15                 if nums[i - 1] == nums[i]:
16                     dp[i + 1] = 1
17                 continue
18             if nums[i] == nums[i - 1]:
19                 dp[i + 1] |= dp[i - 1]
20             if nums[i] == nums[i - 1] == nums[i - 2]:
21                 dp[i + 1] |= dp[i - 2]
22             if nums[i] == nums[i - 1] + 1 == nums[i - 2] + 2:
23                 dp[i + 1] |= dp[i - 2]
24         return dp[-1]

Uriel 2023-08-13 16:42 发表评论

[LeetCode]63. Unique Paths II (Medium) Python-2023.08.12

Uriel — Sat, 12 Aug 2023 08:56:00 GMT

�l�出一个二�l�矩阵，0可以赎ͼ�1代表障碍�Q�每�ơ可以向��x��者向下走�Q�输��Z��左上角到右下角一共多��条路线�Q�DP

1 #63
2 #Runtime: 27 ms (Beats 59.11%)
3 #Memory: 13.3 MB (Beats 82.78%)
4
5 class Solution(object):
6     def uniquePathsWithObstacles(self, obstacleGrid):
7         """
8         :type obstacleGrid: List[List[int]]
9         :rtype: int
10         """
11         n, m = len(obstacleGrid), len(obstacleGrid[0])
12         dp = [[0] * m for _ in range(n)]
13         for i in range(n):
14             if obstacleGrid[i][0] == 0:
15                 dp[i][0] = 1
16             else:
17                 break
18         for i in range(m):
19             if obstacleGrid[0][i] == 0:
20                 dp[0][i] = 1
21             else:
22                 break
23         for i in range(1, n):
24             for j in range(1, m):
25                 if obstacleGrid[i][j] == 0:
26                     dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
27         return dp[-1][-1]

Uriel 2023-08-12 16:56 发表评论

[LeetCode]518. Coin Change II (Medium) Python-2023.08.11

Uriel — Fri, 11 Aug 2023 07:47:00 GMT

有若�q�面值的��币coins�Q�问凑成amount有几�U�方法，背包问题

1 #518
2 #Runtime: 63 ms (Beats 99.47%)
3 #Memory: 13.5 MB (Beats 92.73%)
4
5 class Solution(object):
6     def change(self, amount, coins):
7         """
8         :type amount: int
9         :type coins: List[int]
10         :rtype: int
11         """
12         dp = [0] * (amount + 1)
13         dp[0] = 1
14         for c in coins:
15             for j in range(c, amount + 1):
16                 dp[j] += dp[j - c]
17         return dp[-1]

Uriel 2023-08-11 15:47 发表评论

[LeetCode]95. Unique Binary Search Trees II (Medium) C++/Python-2014.01.11/2023.08.05

Uriel — Sat, 05 Aug 2023 16:44:00 GMT

输出1-n数字�l�成的所有二叉搜索树�Q�递归+dp�Q�用python3的话�q�可以加lru_cache

C++

1 //95
2 //Runtime: 128 ms (Beats 7.1%)
3
4 /**
5  * Definition for binary tree
6  * struct TreeNode {
7  *     int val;
8  *     TreeNode *left;
9  *     TreeNode *right;
10  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
11  * };
12  */
13 class Solution {
14 public:
15     vector sov(int l, int r) {
16         vector ans;
17         if(l > r) ans.push_back(NULL);
18         else {
19             for(int i = l; i <= r; ++i) {
20                 vector left = sov(l, i - 1);
21                 vector right = sov(i + 1, r);
22                 for(int ll = 0; ll < left.size(); ++ll) {
23                     for(int rr = 0; rr < right.size(); ++rr) {
24                         TreeNode *root = new TreeNode(i);
25                         root->left = left[ll];
26                         root->right = right[rr];
27                         ans.push_back(root);
28                     }
29                 }
30             }
31         }
32         return ans;
33     }
34
35     vector generateTrees(int n) {
36         return sov(1, n);
37     }
38 };

Python

1 #95
2 #Runtime: 38 ms (Beats 79.12%)
3 #Memory: 16.2 MB (Beats 63.19%)
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def generateTrees(self, n):
13         """
14         :type n: int
15         :rtype: List[TreeNode]
16         """
17
18         def dp(l, r):
19             if l > r:
20                 return [None]
21             ans = []
22             for i in range(l, r + 1):
23                 l_tree = dp(l, i - 1)
24                 r_tree = dp(i + 1, r)
25                 for ll in l_tree:
26                     for rr in r_tree:
27                         root = TreeNode(i)
28                         root.left = ll
29                         root.right = rr
30                         ans.append(root)
31             return ans
32         return dp(1, n)

Uriel 2023-08-06 00:44 发表评论

[LeetCode]712. Minimum ASCII Delete Sum for Two Strings (Medium) Python-2023.07.31

Uriel — Mon, 31 Jul 2023 11:53:00 GMT

�l�出两个字符串s1和s2�Q�可以各自删除一些字�W��得剩下的两个字符串相同，问删除的字符的ASCII码��g��和最��ؓ多少�Q�DP
转移方程�Q?div style="background-color: #ffffff; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 13px; line-height: 20px; white-space: pre;">

if s1[i - 1] == s2[j - 1]:

dp[i][j] = dp[i - 1][j - 1]

else:

dp[i][j] = min(dp[i - 1][j] + ord(s1[i - 1]), dp[i][j - 1] + ord(s2[j - 1]))

1 #712
2 #Runtime: 427 ms (Beats 68.49%)
3 #Memory: 17.2 MB (Beats 49.31%)
4
5 class Solution(object):
6     def minimumDeleteSum(self, s1, s2):
7         """
8         :type s1: str
9         :type s2: str
10         :rtype: int
11         """
12         n, m = len(s1), len(s2)
13         dp = [[0] * (m + 1) for _ in range(n + 1)]
14         for i in range(1, n + 1):
15             dp[i][0] = dp[i - 1][0] + ord(s1[i - 1])
16         for i in range(1, m + 1):
17             dp[0][i] = dp[0][i - 1] + ord(s2[i - 1])
18         for i in range(1, n + 1):
19             for j in range(1, m + 1):
20                 if s1[i - 1] == s2[j - 1]:
21                     dp[i][j] = dp[i - 1][j - 1]
22                 else:
23                     dp[i][j] = min(dp[i - 1][j] + ord(s1[i - 1]), dp[i][j - 1] + ord(s2[j - 1]))
24         return dp[n][m]

Uriel 2023-07-31 19:53 发表评论

[LeetCode]664. Strange Printer (Hard) Python-2023.07.30

Uriel — Sun, 30 Jul 2023 10:32:00 GMT

�l�出一列字�W�串�Q�一台打字机每次可以打出一串相同的字符�Q�若��x��印aba�Q�可以先打印aaa然后打印b覆盖中间的a�Q�问打印完该串字�W�串要打印几�ơ，DP�Q�思�\参�?->

1 #664
2 #Runtime: 444 ms (Beats 100%)
3 #Memory: 13.2 MB (Beats 100%)
4
5 class Solution(object):
6     def strangePrinter(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         n = len(s)
12         dp = [[101] * n for _ in range(n)]
13         for i in range(n):
14             dp[i][i] = 1
15         for l in range(2, n + 1):
16             for i in range(n - l + 1):
17                 j = i + l - 1
18                 dp[i][j] = dp[i + 1][j] + 1
19                 for k in range(i + 1, j + 1):
20                     if s[i] == s[k]:
21                         dp[i][j] = min(dp[i][j], dp[i][k - 1] + (dp[k + 1][j] if j != k else 0))
22         return dp[0][n - 1]

Uriel 2023-07-30 18:32 发表评论

[LeetCode]808. Soup Servings (Medium) Python3-2023.07.29

Uriel — Sat, 29 Jul 2023 10:07:00 GMT

初始A�Q�B两种汤都有n ml�Q�每�ơ可以执行如下四�U�操作之一�Q�输出A先喝完的概率*1+AB同时喝完的概�?0.5�Q�精�?0^-5�Q�递归+DP�Q�但直接做会��过�q�代深度�Q�参考Discussion发现��p��出精度可以推��n大于某个值的时候可以直接输�?

1 #808
2 #Runtime: 36 ms (Beats 100%)
3 #Memory: 17 MB (Beats 79.25%)
4
5 class Solution:
6     def soupServings(self, n: int) -> float:
7         if n >= 4276:
8             return 1.0
9         @lru_cache(None)
10         def dp(x, y):
11             if x <= 0 and y > 0:
12                 return 1
13             if x <= 0 and y <= 0:
14                 return 0.5
15             if x > 0 and y <= 0:
16                 return 0
17             return (dp(x - 100, y) + dp(x - 75, y - 25) + dp(x - 50, y - 50) + dp(x - 25, y - 75)) * 0.25
18
19         return dp(1.0 * n, 1.0 * n)

Uriel 2023-07-29 18:07 发表评论

[LeetCode]486. Predict the Winner (Medium) Python3-2023.07.28

Uriel — Fri, 28 Jul 2023 09:37:00 GMT

一个数列，每个��g��表score�Q�两个player每次可以从数列头or��N��一个数�Q�问最后谁的总score最高，递归+DP�Q�参考了Discussion -> https://leetcode.com/problems/predict-the-winner/solutions/3826270/python3-solution/

1 #486
2 #Runtime: 41 ms (Beats 96.36%)
3 #Memory: 16.7 MB (Beats 19.78%)
4
5 class Solution:
6     def PredictTheWinner(self, nums: List[int]) -> bool:
7         n = len(nums)
8         @lru_cache(None)
9         def dp(i, j):
10             return 0 if i > j else max(-dp(i + 1, j) + nums[i], -dp(i, j - 1) + nums[j])
11
12         return dp(0, n -1) >= 0

Uriel 2023-07-28 17:37 发表评论

[LeetCode]894. All Possible Full Binary Trees (Medium) Python3-2023.07.23

Uriel — Sun, 23 Jul 2023 11:13:00 GMT

输出n个节�Ҏ��成的所有完全二叉树�Q�DP�Q�参考了Discussion -> https://leetcode.com/problems/all-possible-full-binary-trees/solutions/3803284/python3-solution/

1 #894
2 #Runtime: 148 ms (Beats 81.71%)
3 #Memory: 17 MB (Beats 80.49%)
4
5
6 # Definition for a binary tree node.
7 # class TreeNode(object):
8 #     def __init__(self, val=0, left=None, right=None):
9 #         self.val = val
10 #         self.left = left
11 #         self.right = right
12 class Solution(object):
13     def allPossibleFBT(self, n):
14         """
15         :type n: int
16         :rtype: List[TreeNode]
17         """
18         if n % 2 == 0:
19             return []
20         dp = [[] for _ in range(n + 1)]
21         dp[1] = [TreeNode(0)]
22         for i in range(3, n + 1):
23             for j in range(1, i):
24                 l_tree = dp[j]
25                 r_tree = dp[i - 1 - j]
26                 for l_t in l_tree:
27                     for r_t in r_tree:
28                         root = TreeNode(0)
29                         root.left = l_t
30                         root.right = r_t
31                         dp[i].append(root)
32         return dp[n]

Uriel 2023-07-23 19:13 发表评论

[LeetCode]673. Number of Longest Increasing Subsequence (Medium) Python-2023.07.21

Uriel — Fri, 21 Jul 2023 06:46:00 GMT

一个数串最长子序列一共有多少个（严格递增�Q�，DP�Q�dp记录截止�W�i个数的最长子序列长度�Q�nt记录截止i的最长子序列个数

#673
#Runtime: 1392 ms (Beats 5.5%)
#Memory: 13.6 MB (Beats 77.78%)

class Solution(object):
    def findNumberOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        n = len(nums)
        dp = [0] * n
        dp[0] = 1
        nt = [0] * n
        nt[0] = 1
        ll = 1
        for i in range(1, len(nums)):
            mx = 0
            fq = 1
            for j in range(i):
                if nums[j] < nums[i]:
                    if dp[j] > mx:
                        mx = dp[j]
                        fq = nt[j]
                    elif dp[j] == mx:
                        fq += nt[j]
                nt[i] = fq
                dp[i] = mx + 1
                if ll < dp[i]:
                    ll = dp[i]
        ans = 0
        for i in range(len(dp)):
            if dp[i] == ll:
                ans += nt[i]
        return ans

Uriel 2023-07-21 14:46 发表评论

[LeetCode]1125. Smallest Sufficient Team (Hard) Python-2023.07.16

Uriel — Sun, 16 Jul 2023 10:16:00 GMT

�l�出需要的skill list和每个�h的skill�Q�问最��需要其中的几个人可以满��skill list里面所有skill
二进制表�C�skill+DP�Q�参考Discussion -> https://leetcode.com/problems/smallest-sufficient-team/solutions/3771208/detailed-video-solution-java-python/

#1125
#Runtime: 121 ms (Beats 88.89%)
#Memory: 18.1 MB (Beats 44.44%)

class Solution(object):
    def smallestSufficientTeam(self, req_skills, people):
        """
        :type req_skills: List[str]
        :type people: List[List[str]]
        :rtype: List[int]
        """
        n_p = len(people)
        n_s = len(req_skills)
        sk_map = {sk: i for i, sk in enumerate(req_skills)}
        dp = [None] * (1 << n_s)
        dp[0] = []
        sk_p = []
        for i in range(n_p):
            t = 0
            for sk in people[i]:
                t |= 1 << sk_map[sk]
            sk_p.append(t)
        discard_p = [False] * n_p
        for i in range(n_p):
            for j in range(i + 1, n_p):
                if (sk_p[j] | sk_p[i]) == sk_p[i]:
                    discard_p[j] = True
                elif (sk_p[j] | sk_p[i]) == sk_p[j]:
                    discard_p[i] = True
        for i in range(n_p):
            if not discard_p[i]:
                for j in range(len(dp)):
                    if dp[j] is None:
                        continue
                    t = j | sk_p[i]
                    if dp[t] is None or len(dp[j]) + 1 < len(dp[t]):
                        dp[t] = dp[j] + [i]
        return dp[(1 << n_s) - 1]

Uriel 2023-07-16 18:16 发表评论

[LeetCode]1218. Longest Arithmetic Subsequence of Given Difference (Medium) Python-2023.07.14

Uriel — Fri, 14 Jul 2023 09:15:00 GMT

�l�出一列数和等差数列的盔R��C��差，问符合这个差值的最长的子串长度�Q�DP+hash

1 #1218
2 #Runtime: 499 ms (Beats 50%)
3 #Memory: 24.2 MB (Beats 100%)
4
5 class Solution(object):
6     def longestSubsequence(self, arr, difference):
7         """
8         :type arr: List[int]
9         :type difference: int
10         :rtype: int
11         """
12         ans = 0
13         num = {}
14         for i in range(len(arr)):
15             t = arr[i]
16             if t - difference in num:
17                 num[t] = num[t - difference] + 1
18             else:
19                 num[t] = 1
20             ans = max(ans, num[t])
21         return ans

Uriel 2023-07-14 17:15 发表评论

[LeetCode]2272. Substring With Largest Variance (Hard) Python-2023.07.09

Uriel — Sun, 09 Jul 2023 10:54:00 GMT

求一个字�W�串的子�Ԍ��使得其中字母的出现次数最大最��值差距最大（子串需要下标连�l�取�Q?br />DP�Q�思�\参�?-> https://leetcode.com/problems/substring-with-largest-variance/solutions/2579443/python-3-solution-kadanes/

1 #2272
2 #Runtime: 5894 ms (Beats 50%)
3 #Memory: 13.9 MB (Beats 20%)
4
5 class Solution(object):
6     def largestVariance(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         f1, f2, ans = 0, 0, 0
12         pairs = [(x, y) for x in set(s) for y in set(s) if x != y]
13         for _ in range(2):
14             for p in pairs:
15                 for l in s:
16                     if l not in p:
17                         continue
18                     if l == p[0]:
19                         f1 += 1
20                     elif l == p[1]:
21                         f2 += 1
22                     if f1 < f2:
23                         f1, f2 = 0, 0
24                     elif f1 and f2:
25                         ans = max(ans, f1 - f2)
26                 f1, f2 = 0, 0
27             s = s[::-1]
28         return ans

Uriel 2023-07-09 18:54 发表评论

[LeetCode]956. Tallest Billboard (Hard) Python-2023.06.24

Uriel — Sun, 25 Jun 2023 14:34:00 GMT

��一个二�l�数�l�分为加和相�{�的两拨�Q�问最大的和是多少�Q�不存在的话输出0�Q?br />递归DP+memorization�Q�参考了Discussion -> https://leetcode.com/problems/tallest-billboard/solutions/3675264/python3-solution/

1 #956
2 #Runtime: 960 ms (Beats 33.33%)
3 #Memory: 121.3 MB (Beats 11.11%)
4
5 class Solution(object):
6     def tallestBillboard(self, rods):
7         """
8         :type rods: List[int]
9         :rtype: int
10         """
11         ans = {}
12         def DFS(i, dif):
13             if (i, dif) in ans:
14                 return ans[(i, dif)]
15             if i >= len(rods):
16                 if dif:
17                     return float('-inf')
18                 return 0
19             l = DFS(i + 1, dif + rods[i])
20             skip = DFS(i + 1, dif)
21             s = DFS(i + 1, abs(rods[i] - dif)) + min(dif, rods[i])
22             ans[(i, dif)] = max(l, s, skip)
23             return ans[(i, dif)]
24
25
26         return DFS(0, 0)

Uriel 2023-06-25 22:34 发表评论

[LeetCode]1575. Count All Possible Routes (Hard) Python3-2023.06.25

Uriel — Sun, 25 Jun 2023 14:30:00 GMT

�l�出每个城市i的locations[i]�Q�以及�v始、终点城市和初始汽��a量，从城市i到j需要耗费汽��a｜locations[i]-locations[j]｜，问一共有多少条�\�U?/div>

递归DP+memorization�Q�用python3的lru_cache�Q?br />参考了Discussion -> https://leetcode.com/problems/count-all-possible-routes/solutions/3678855/python3-solution/

1 #1575
2 #Runtime: 2024 ms (Beats 68.42%)
3 #Memory: 41.4 MB (Beats 12.3%)
4
5 class Solution:
6     def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
7         MOD = 10 ** 9 + 7
8
9         @lru_cache(None)
10         def DP(p, x):
11             if x < 0:
12                 return 0
13             t = 0
14             if p == finish:
15                 t += 1
16             for i in range(len(locations)):
17                 if i != p:
18                     t += DP(i, x - abs(locations[i] - locations[p]))
19             return t
20
21         return DP(start, fuel) % MOD

Uriel 2023-06-25 22:30 发表评论