C++博客-Uriel's Corner-文章分类-闲来无事重切Leet Code

[LeetCode]238. Product of Array Except Self (Medium) Python-2024.04.15

Uriel — Fri, 15 Mar 2024 09:55:00 GMT

给出一个数组nums，输出同样长度的数组，每个元素值为该数组所有数字的乘积除以nums[i]，要求不用除法
先从左到右扫一遍算prefix product，再从后向左扫一遍算suffix product

1 #576
2 #Runtime: 177 ms (Beats 26.93%)
3 #Memory: 17.4 MB (Beats 96.45%)
4
5 class Solution(object):
6     def productExceptSelf(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         t = 1
12         ans = []
13         for i in xrange(len(nums)):
14             ans.append(t)
15             t *= nums[i]
16         t = 1
17         for i in xrange(len(nums) - 1, -1, -1):
18             ans[i] *= t
19             t *= nums[i]
20         return ans
21

Uriel 2024-03-15 17:55 发表评论

[LeetCode]977. Squares of a Sorted Array (Easy) Python-2024.03.02

Uriel — Sat, 02 Mar 2024 10:17:00 GMT

给出一个已经从小到大排序的有正有负的数组，输出每个元素的平方并且也要从小到大排序。设两个指针从左和右端向中间扫，之后在逆序输出。

1 #977
2
3 class Solution(object):
4     def sortedSquares(self, nums):
5         """
6         :type nums: List[int]
7         :rtype: List[int]
8         """
9         l = 0
10         r = len(nums) - 1
11         ans = []
12         while l <= r:
13             if nums[l] * nums[l] > nums[r] * nums[r]:
14                 ans.append(nums[l] * nums[l])
15                 l += 1
16             else:
17                 ans.append(nums[r] * nums[r])
18                 r -= 1
19         return ans[::-1]

Uriel 2024-03-02 18:17 发表评论

[LeetCode]739. Daily Temperatures (Medium) Python-2024.01.31

Uriel — Wed, 31 Jan 2024 10:05:00 GMT

早前的写法是倒序->http://www.cppblog.com/Uriel/articles/229495.html
改了正序写法，快了不少

1 #739
2 #Runtime: 998 ms (Beats 89.58%)
3 #Memory: 23.6 MB (Beats 98.27%)
4
5 class Solution(object):
6     def dailyTemperatures(self, temperatures):
7         """
8         :type temperatures: List[int]
9         :rtype: List[int]
10         """
11         ans = [0] * len(temperatures)
12         stk = []
13         for i, t in enumerate(temperatures):
14             if not stk:
15                 stk.append(i)
16             else:
17                 while stk and temperatures[stk[-1]] < t:
18                     idx = stk.pop()
19                     ans[idx] = i - idx
20                 stk.append(i)
21         return ans

Uriel 2024-01-31 18:05 发表评论

[LeetCode]1074. Number of Submatrices That Sum to Target (Hard) Python-2024.01.28

Uriel — Sun, 28 Jan 2024 11:50:00 GMT

给出二维矩阵matrix，求其中满足矩阵和等于target的子矩阵有几个，O(n^4)暴力可过，计算矩阵的prefix sum再同时枚举所有可能

1 #1074
2 #Runtime: 9219 ms (Beats 7.69%)
3 #Memory: 12.6 MB (Beats 100%)
4
5 class Solution(object):
6     def numSubmatrixSumTarget(self, matrix, target):
7         """
8         :type matrix: List[List[int]]
9         :type target: int
10         :rtype: int
11         """
12         ans = 0
13         n, m = len(matrix), len(matrix[0])
14         pre_sum = [[0] * (m + 1) for _ in xrange(n + 1)]
15         for i in xrange(1, n + 1):
16             for j in xrange(1, m + 1):
17                 pre_sum[i][j] = pre_sum[i - 1][j] + pre_sum[i][j - 1] + matrix[i - 1][j - 1] - pre_sum[i - 1][j - 1]
18                 for x in xrange(0, i):
19                     for y in xrange(0, j):
20                         if target == pre_sum[i][j] + pre_sum[x][y] - pre_sum[x][j] - pre_sum[i][y]:
21                             ans += 1
22         return ans

Uriel 2024-01-28 19:50 发表评论

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

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

给出二维grid的长度高度m宽度n，和初始球在的位置(startRow, startColumn)，问经过最多maxMove步，每次可以移动球到上下左右七种一格，有几种方式出界，DP
用一个临时变量t保存上一轮dp的状态，可以节省空间

#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]1457. Pseudo-Palindromic Paths in a Binary Tree (Medium) Python-2024.01.24

Uriel — Wed, 24 Jan 2024 11:26:00 GMT

思路参考->https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/solutions/2573237/leetcode-the-hard-way-explained-line-by-line/?envType=daily-question&envId=2024-01-24

1 #1457
2 #Runtime: 911 ms (Beats 96.43%)
3 #Memory: 136.7 MB (Beats 10.71%)
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 pseudoPalindromicPaths (self, root, cnt = 0):
13         """
14         :type root: TreeNode
15         :rtype: int
16         """
17         if not root:
18             return 0
19         cnt ^= 1 << (root.val - 1)
20         if root.left is None and root.right is None:
21             return 1 if cnt & (cnt - 1) == 0 else 0
22         return self.pseudoPalindromicPaths(root.left, cnt) + self.pseudoPalindromicPaths(root.right, cnt)
23

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

[LeetCode]1239. Maximum Length of a Concatenated String with Unique Characters (Medium) Python-2024.01.23

Uriel — Tue, 23 Jan 2024 10:54:00 GMT

给出一些字符串，问取其中若干字符串能拼出的不含重复字母的最长字串
先过滤掉自身有重复字母的，然后设一个内含set的列表，每次扫一遍列表看能否加入当前字符串，最后取列表中最多字母的set

#1239
#Runtime: 97 ms (Beats 50%)
#Memory: 53.4 MB (Beats 8.49%)

class Solution(object):
    def maxLength(self, arr):
        """
        :type arr: List[str]
        :rtype: int
        """
        candidate = []
        for s in arr:
            u = set(s)
            if len(s) == len(u):
                candidate.append(u)
        ans = [set()]
        maxx = 0
        for i in candidate:
            for j in ans:
                if not i & j:
                    ans.append(i | j)
                    maxx = max(maxx, len(i | j))
        return maxx

Uriel 2024-01-23 18:54 发表评论

[LeetCode]2610. Convert an Array Into a 2D Array With Conditions (Medium) Python-2024.01.02

Uriel — Tue, 02 Jan 2024 13:04:00 GMT

给出一列数来构造数组，数组每一行由不同的数字组成，每行长度可以不一样，输出其中一种可行解
用python的Counter统计每个数字出现次数，再一次构造每一行

1 #2610
2 #Runtime: 60 ms (Beats 13.89%)
3 #Memory: 13.3 MB (Beats 80.56%)
4
5 class Solution(object):
6     def findMatrix(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[List[int]]
10         """
11         ans = []
12         cnt = Counter(nums)
13         while cnt:
14             tp = []
15             used = []
16             for i, v in cnt.items():
17                 tp.append(i)
18                 cnt[i] -= 1
19                 if cnt[i] == 0:
20                     used.append(i)
21             for i in used:
22                 cnt.pop(i)
23             ans.append(tp)
24         return ans

Uriel 2024-01-02 21:04 发表评论

[LeetCode]455. Assign Cookies (Easy) Python-2024.01.01

Uriel — Mon, 01 Jan 2024 13:13:00 GMT

数组g表示每个小盆友需要什么size的饼干，数组s表示每个饼干的size，问这堆饼干s最多能满足多少位小盆友的要求，贪心，分别对g和s从小到大排序，然后设两个游标挨个比较

1 #455
2 #Runtime: 230 ms (Beats 12.76%)
3 #Memory: 15 MB (Beats 6.38%)
4
5 class Solution(object):
6     def findContentChildren(self, g, s):
7         """
8         :type g: List[int]
9         :type s: List[int]
10         :rtype: int
11         """
12         g.sort()
13         s.sort()
14         p1, p2 = 0, 0
15         while p1 < len(g) and p2 < len(s):
16             if g[p1] <= s[p2]:
17                 p1 += 1
18                 p2 += 1
19             else:
20                 p2 += 1
21         return p1

Uriel 2024-01-01 21:13 发表评论

[LeetCode]1897. Redistribute Characters to Make All Strings Equal (Easy) Python-2023.12.30

Uriel — Sat, 30 Dec 2023 13:21:00 GMT

一个words集合包含若干字符串，每次操作可以将其中一个字符串的某个字符插入另一个字符串，问是否可以经过无限次操作使得每个字符串变成相同的。直接判断是否每个字符的总出现次数可以被字符串数量整除即可

1 #1897
2 #Runtime: 67 ms (Beats 16.67%)
3 #Memory: 13.6 MB (Beats 83.33%)
4
5 class Solution(object):
6     def makeEqual(self, words):
7         """
8         :type words: List[str]
9         :rtype: bool
10         """
11         total = ''.join(words)
12         chars = set(total)
13         for ch in chars:
14             if total.count(ch) % len(words) != 0:
15                 return False
16         return True

Uriel 2023-12-30 21:21 发表评论

[LeetCode]1578. Minimum Time to Make Rope Colorful (Medium) Python-2023.12.27

Uriel — Wed, 27 Dec 2023 09:38:00 GMT

a-z代表不同颜色的气球，相邻气球颜色相同的话每次可以保留其中一个，花费时间为二者needTime中间的较小值，问消除全部的相邻气球的最小总花费，贪心

#1578
#Runtime: 812 ms (Beats 62.22%)
#Memory: 22.1 MB (Beats 88.89%)

class Solution(object):
    def minCost(self, colors, neededTime):
        """
        :type colors: str
        :type neededTime: List[int]
        :rtype: int
        """
        ans = 0
        for i in xrange(1, len(neededTime)):
            if colors[i] == colors[i - 1]:
                ans += min(neededTime[i], neededTime[i - 1])
                neededTime[i] = max(neededTime[i - 1], neededTime[i])
        return ans

Uriel 2023-12-27 17:38 发表评论

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

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

给出一列数，按照A-Z对应1-26，问这列数有几种拆分成字符串的方式，DP，只要考虑当前位1-9以及最近两位数10-26的情况

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]1758. Minimum Changes To Make Alternating Binary String (Easy) Python-2023.12.24

Uriel — Sun, 24 Dec 2023 10:27:00 GMT

给出一个0-1字符串，问最少操作几次可以将字符串变为....0-1-0-1....用两个计数器记录首位取0和取1分别要操作几次，取两者较小值

#1758
#Runtime: 25 ms (Beats 79.41%)
#Memory: 13.4 MB (Beats 88.24)

class Solution(object):
    def minOperations(self, s):
        """
        :type s: str
        :rtype: int
        """
        ans1, ans2 = 0, 0
        for i in xrange(0, len(s)):
            if i % 2:
                if s[i] == '0':
                    ans1 += 1
                else:
                    ans2 += 1
            else:
                if s[i] == '1':
                    ans1 += 1
                else:
                    ans2 += 1
        return min(ans1, ans2)

Uriel 2023-12-24 18:27 发表评论

[LeetCode]1496. Path Crossing (Easy) Python-2023.12.23

Uriel — Sat, 23 Dec 2023 13:51:00 GMT

给出一列数，包含NSWE代表朝这四个方向走一步，问是否会经过相同的格点，用python的dict记录每次到达的格点即可

1 #1496
2 #Runtime: 16 ms (Beats 59.29%)
3 #Memory: 13.5 MB (Beats 76.11%)
4
5 class Solution(object):
6     def isPathCrossing(self, path):
7         """
8         :type path: str
9         :rtype: bool
10         """
11         x, y = 0, 0
12         cor = {(x, y)}
13         for ch in path:
14             if ch == 'N':
15                 y += 1
16             elif ch == 'S':
17                 y -= 1
18             elif ch == 'E':
19                 x += 1
20             else:
21                 x -= 1
22             if (x, y) in cor:
23                 return True
24             cor.add((x, y))
25         return False

Uriel 2023-12-23 21:51 发表评论

[LeetCode]1422. Maximum Score After Splitting a String (Easy) Python-2023.13.22

Uriel — Fri, 22 Dec 2023 08:35:00 GMT

将一个01字符串切割成两个非空子串，最大化第一个字符串的0和第二个字符串的1，先统计1的总个数，再从左到右扫一遍找最佳切割位置

1 #1422
2 #Runtime: 13 ms (Beats 90.28%)
3 #Memory: 13.3 MB (Beats 56.94%)
4
5 class Solution(object):
6     def maxScore(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         ones = s[1:].count('1')
12         if s[0] == '0':
13             zeros = 1
14         else:
15             zeros = 0
16         ans = ones + zeros
17         for i in xrange(1, len(s) - 1):
18             if s[i] == '0':
19                 zeros += 1
20             else:
21                 ones -= 1
22             ans = max(ans, ones + zeros)
23         return ans

Uriel 2023-12-22 16:35 发表评论

[LeetCode]242. Valid Anagram (Easy) Python-2023.12.16

Uriel — Sat, 16 Dec 2023 10:28:00 GMT

求问两个字符串是否由完全相同的字母不同的组合而成，用python的count判断每个字出现次数

#242
#Runtime: 20 ms (Beats 96.2%)
#Memory: 13.7 MB (Beats 69.85%)

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t):
            return False
        for i in set(s):
            if s.count(i) != t.count(i):
                return False
        return True

Uriel 2023-12-16 18:28 发表评论

[LeetCode]1436. Destination City (Easy) Python-2023.12.15

Uriel — Fri, 15 Dec 2023 08:28:00 GMT

给出每一条路的起始和终止城市（string），输出唯一的终点城市（没有从该城市出发的任何路），数据保证结果唯一，两个hash表，一个存所有出现过的城市，一个存所有作为过起点的城市

1 #1436
2 #Runtime: 34 ms (Beats 59.12%)
3 #Memory: 13.6 MB (Beats 19.34%)
4
5 class Solution(object):
6     def destCity(self, paths):
7         """
8         :type paths: List[List[str]]
9         :rtype: str
10         """
11         st = set()
12         cities = set()
13         for x, y in paths:
14             st.add(x)
15             cities.add(x)
16             cities.add(y)
17         for x in cities:
18             if x not in st:
19                 return x

Uriel 2023-12-15 16:28 发表评论

[LeetCode]2482. Difference Between Ones and Zeros in Row and Column (Medium) Python-2023.12.14

Uriel — Thu, 14 Dec 2023 14:49:00 GMT

给出一个0-1矩阵，输出一个一样大小的矩阵，其中每个元素代表原先矩阵对应行和列的1的个数减去0的个数，O(n^2)直接做

1 #2482
2 #Runtime: 1162 ms (Beats 74.29%)
3 #Memory: 44.6 MB (Beats 80%)
4
5 class Solution(object):
6     def onesMinusZeros(self, grid):
7         """
8         :type grid: List[List[int]]
9         :rtype: List[List[int]]
10         """
11         n, m = len(grid), len(grid[0])
12         r = [0] * n
13         c = [0] * m
14         for i in xrange(n):
15             for j in xrange(m):
16                 r[i] += grid[i][j]
17                 c[j] += grid[i][j]
18         for i in xrange(n):
19             for j in xrange(m):
20                 grid[i][j] = 2 * r[i] + 2 * c[j] - n - m
21         return grid

Uriel 2023-12-14 22:49 发表评论

[LeetCode]1582. Special Positions in a Binary Matrix (Easy) Python-2023.12.13

Uriel — Wed, 13 Dec 2023 11:24:00 GMT

求问一个二维矩阵某个元素为其对应行和列唯一一个1的元素个数，用python的count很方便

1 #1582
2 #Runtime: 121 ms (Beats 70.97%)
3 #Memory: 13.6 MB (Beats 35.48%)
4
5 class Solution(object):
6     def numSpecial(self, mat):
7         """
8         :type mat: List[List[int]]
9         :rtype: int
10         """
11         ans = 0
12         for i in xrange(len(mat)):
13             if mat[i].count(1) == 1:
14                 x = mat[i].index(1)
15                 col = [r[x] for r in mat]
16                 if col.count(1) == 1:
17                     ans += 1
18         return ans

Uriel 2023-12-13 19:24 发表评论

[LeetCode]1903. Largest Odd Number in String (Easy) Python-2023.12.07

Uriel — Fri, 08 Dec 2023 16:16:00 GMT

输出一个字符串的最大奇数子串，贪心，从最后一位向前找奇数

1 #1903
2 #Runtime: 27 ms (Beats 98.59%)
3 #Memory: 15.3 MB (Beats 81.69%)
4
5 class Solution(object):
6     def largestOddNumber(self, num):
7         """
8         :type num: str
9         :rtype: str
10         """
11         p = -1
12         for i in xrange(len(num) - 1, -1, -1):
13             if (ord(num[i]) - ord('0')) % 2:
14                 p = i
15                 break
16         return num[0:p+1]
17

Uriel 2023-12-09 00:16 发表评论

[LeetCode]606. Construct String from Binary Tree (Easy) Python-2023.12.08

Uriel — Fri, 08 Dec 2023 16:12:00 GMT

先序遍历二叉树并且格式化输出，DFS
注意如果只有右子树、左子树为空的话也要输出左子树的一对括号

1 #606
2 #Runtime: 44 ms (Beats 7.3%)
3 #Memory: 16.2 MB (Beats 35.94%)
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 tree2str(self, root):
13         """
14         :type root: TreeNode
15         :rtype: str
16         """
17         self.ans = ""
18         def DFS(node):
19             self.ans += str(node.val)
20             if node.left or node.right:
21                 self.ans += '('
22                 if node.left:
23                     DFS(node.left)
24                 self.ans += ')'
25                 if node.right:
26                     self.ans += '('
27                     DFS(node.right)
28                     self.ans += ')'
29
30         if root:
31             DFS(root)
32         return self.ans

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

[LeetCode]2264. Largest 3-Same-Digit Number in String (Easy) Python-2023.12.04

Uriel — Mon, 04 Dec 2023 10:51:00 GMT

输出一个字符串中连续出现三次以上的数字字符（多解的话输出最大的数字），水题

1 #2264
2 #Runtime: 17 ms (Beats 71.79%)
3 #Memory: 13.4 MB (Beats 46.15%)
4
5 class Solution(object):
6     def largestGoodInteger(self, num):
7         """
8         :type num: str
9         :rtype: str
10         """
11         x = '/'
12         t = 1
13         for i in xrange(1, len(num)):
14             if num[i] == num[i - 1]:
15                 t += 1
16                 if t >= 3:
17                     x = max(x, num[i])
18                     print(x)
19             else:
20                 t = 1
21         if x >= '0':
22             return x * 3
23         return ""

Uriel 2023-12-04 18:51 发表评论

[LeetCode]1160. Find Words That Can Be Formed by Characters (Easy) Python-2023.12.02

Uriel — Sat, 02 Dec 2023 04:19:00 GMT

判断words里面每一个word是否能由chars中的字母组成，输出所有可以组成的word的总长度，用python的count

1 #1160
2 #Runtime: 71 ms (Beats 71.98%)
3 #Memory: 14.4 MB (Beats 7.69%)
4
5 class Solution(object):
6     def countCharacters(self, words, chars):
7         """
8         :type words: List[str]
9         :type chars: str
10         :rtype: int
11         """
12         ans = ''
13         for w in words:
14             for ch in w:
15                 if chars.count(ch) < w.count(ch):
16                     break
17             else:
18                 ans += w
19         return len(ans)

Uriel 2023-12-02 12:19 发表评论

[LeetCode]1727. Largest Submatrix With Rearrangements (Medium) Python3-2023.12.01

Uriel — Fri, 01 Dec 2023 13:36:00 GMT

rearrange二维矩阵的列，问能构成的最大的全1子矩阵有多大，贪心，先按列求每一行的prefix sum（因为行顺序不能换，所以遇到0的话要清0），然后遍历每一行，更新最大子矩阵尺寸

1 #1727
2 #Runtime: 1041 ms (Beats 11.18%)
3 #Memory: 44.8 MB (Beats 45.71%)
4
5 class Solution(object):
6     def largestSubmatrix(self, matrix):
7         """
8         :type matrix: List[List[int]]
9         :rtype: int
10         """
11         r, c = len(matrix), len(matrix[0])
12         ans = 0
13         for i in xrange(1, r):
14             for j in xrange(c):
15                 matrix[i][j] += matrix[i - 1][j] if matrix[i][j] else 0
16         for i in xrange(r):
17             matrix[i].sort(reverse=True)
18             for j in xrange(c):
19                 ans = max(ans, (j + 1) * matrix[i][j])
20         return ans

Uriel 2023-12-01 21:36 发表评论

[LeetCode]1611. Minimum One Bit Operations to Make Integers Zero (Hard) Python-2023.11.30

Uriel — Thu, 30 Nov 2023 17:41:00 GMT

给出一个十进制数，问其二进制表示通过以下两种操作几次可以变成0

1. Change the rightmost (0th) bit in the binary representation of n.

2. Change the ith bit in the binary representation of n if the (i-1)th bit is set to 1 and the (i-2)th through 0th bits are set to 0.

很妙的思路参考 -> https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/solutions/2273798/easy-to-understand-6-line-solution-with-explanation-o-n-time-o-1-space/?envType=daily-question&envId=2023-11-30

1 #1611
2 #Runtime: 17 ms (Beats 66.67%)
3 #Memory: 13.4 MB (Beats 33.33%)
4
5 class Solution(object):
6     def minimumOneBitOperations(self, n):
7         """
8         :type n: int
9         :rtype: int
10         """
11         binary = format(n, "b")
12         ans = 0
13         for i in xrange(1, len(binary) + 1):
14             if binary[-i] == "1":
15                 ans = 2**i - 1 - ans
16         return ans

Uriel 2023-12-01 01:41 发表评论

[LeetCode]1424. Diagonal Traverse II (Medium) Python-2023.11.22

Uriel — Wed, 22 Nov 2023 10:22:00 GMT

按从左下到右上斜着输出一个二维数组的值（数组有缺失值）

1 #1424
2 #Runtime: 724 ms (Beats 27.21%)
3 #Memory: 40.3 MB (Beats 41.50%)
4
5 class Solution(object):
6     def findDiagonalOrder(self, nums):
7         """
8         :type nums: List[List[int]]
9         :rtype: List[int]
10         """
11         ans = defaultdict(list)
12         for x in xrange(len(nums)):
13             for y in xrange(len(nums[x])):
14                 ans[x + y].append(nums[x][y])
15         return [y for x in ans.keys() for y in reversed(ans[x])]

Uriel 2023-11-22 18:22 发表评论

[LeetCode]1814. Count Nice Pairs in an Array (Medium) Python-2023.11.21

Uriel — Tue, 21 Nov 2023 13:48:00 GMT

给出一个数组，问其中有多少个a，b数对，符合a+rev(b)=b+rev(a)，rev为数字反转
a+rev(b)=b+rev(a) -> a - rev(a) + b - rev(b) = 0，所以预处理所有a-rev(a)，然后用Counter计算每种value出现次数然后累加

#1814
#Runtime: 586 ms (Beats 78.13%)
#Memory: 23 MB (Beats 43.75%)

class Solution(object):
    def countNicePairs(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums = [x - int(str(x)[::-1]) for x in nums]
        ans = 0
        for x in Counter(nums).values():
            ans = (ans + (x - 1) * x // 2) % (10**9 + 7)
        return ans

Uriel 2023-11-21 21:48 发表评论

[LeetCode]2391. Minimum Amount of Time to Collect Garbage (Medium) Python-2023.11.20

Uriel — Mon, 20 Nov 2023 09:29:00 GMT

有n个站点需要收垃圾，有MPG三种垃圾，每种垃圾每出现一次需要1个单位时间回收，从i到i+1车辆运行时间travel[i]，问回收完所有垃圾需要多久，模拟

1 #2391
2 #Runtime: 900 ms (Beats 27%)
3 #Memory: 42.5 MB (Beats 81%)
4
5 class Solution(object):
6     def garbageCollection(self, garbage, travel):
7         """
8         :type garbage: List[str]
9         :type travel: List[int]
10         :rtype: int
11         """
12         ans = 0
13         last = [-1, -1, -1]
14         cnt = [0, 0, 0]
15         for i, st in enumerate(garbage):
16             for ch in st:
17                 if ch == 'M':
18                     last[0] = i
19                 if ch == 'P':
20                     last[1] = i
21                 if ch == 'G':
22                     last[2] = i
23             ans += len(st)
24         for i in xrange(len(travel)):
25             if last[0] >= i + 1:
26                 ans += travel[i]
27             if last[1] >= i + 1:
28                 ans += travel[i]
29             if last[2] >= i + 1:
30                 ans += travel[i]
31         return ans

Uriel 2023-11-20 17:29 发表评论

[LeetCode]1887. Reduction Operations to Make the Array Elements Equal (Medium) Python-2023.11.19

Uriel — Sun, 19 Nov 2023 12:00:00 GMT

给出一列数，每次将其中最大的数变成第二大的数，问最少几次可以把所有数变成一样，sort然后按不同数字出现次数加和

Time complexity: O(nlogn)

Space complexity: O(1)

1 #1887
2 #Runtime: 768 ms (Beats 100%)
3 #Memory: 19.2 MB (Beats 66.67%)
4
5 class Solution(object):
6     def reductionOperations(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         nums.sort()
12         nt_sum = 0
13         pre = nums[-1]
14         nt = 1
15         ans = 0
16         for i in xrange(len(nums) - 2, -1, -1):
17             if nums[i] == pre:
18                 nt += 1
19             else:
20                 nt_sum += nt
21                 ans += nt_sum
22                 nt = 1
23                 pre = nums[i]
24         return ans

Uriel 2023-11-19 20:00 发表评论

[LeetCode]1877. Minimize Maximum Pair Sum in Array (Medium) Python-2023.11.17

Uriel — Fri, 17 Nov 2023 13:10:00 GMT

给出一列数，将其中的数分成若干pair要求pair之和的最大值最小，sort然后贪心每次从最小和最大的一端取一个数

1 #1877
2 #Runtime: 939 ms (Beats 68.83%)
3 #Memory: 25.7 MB (Beats 14.29%)
4
5 class Solution(object):
6     def minPairSum(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         nums.sort()
12         ans = 0
13         n = len(nums)
14         for i in xrange(n//2):
15             ans = max(ans, nums[i] + nums[n - i - 1])
16         return ans

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