#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 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

 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-14 17:27 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

 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]

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

 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 发表评论

 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 发表评论

 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 发表评论

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

 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 };

 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 发表评论

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

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

 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 发表评论

 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 发表评论

 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<TreeNode *> sov(int l, int r) {
16         vector<TreeNode *> ans;
17         if(l > r) ans.push_back(NULL);
18         else {
19             for(int i = l; i <= r; ++i) {
20                 vector<TreeNode *> left = sov(l, i - 1);
21                 vector<TreeNode *> 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<TreeNode *> generateTrees(int n) {
36         return sov(1, n);
37     }
38 };

 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 发表评论

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

 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 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

#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 发表评论

#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 发表评论

 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 发表评论

 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 发表评论

 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 发表评论

给出每个城市i的locations[i]，以及起始、终点城市和初始汽油量，从城市i到j需要耗费汽油｜locations[i]-locations[j]｜，问一共有多少条路线

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

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