C++博客-Uriel's Corner-文章分类-位运算

[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]1980. Find Unique Binary String (Medium) Python-2023.11.16

Uriel — Thu, 16 Nov 2023 11:49:00 GMT

给出n个长度为n的二进制数，输出任何一个同样长度为n且与这n个数都不同的二进制数，python的bin()可以方便转二进制

#1980
#Runtime: 11 ms (Beats 91.4%)
#Memory: 13.5 MB (Beats 47.76%)

class Solution(object):
    def findDifferentBinaryString(self, nums):
        """
        :type nums: List[str]
        :rtype: str
        """
        n = len(nums)
        num_set = set(int(x, 2) for x in nums)
        def change_to_n_bit(x, n):
            return ("0"*(n - len(x))) + x
        for x in xrange(1<            if x not in num_set:
                return change_to_n_bit(bin(x)[2:], n)

Uriel 2023-11-16 19:49 发表评论

[LeetCode]338. Counting Bits (Easy) Python-2023.09.01

Uriel — Sun, 03 Sep 2023 07:51:00 GMT

输入n，输出从0~n每个数二进制表示的1的数量
O(n)复杂度的方法比较巧妙：1000..0这样的数1的数量一定是1，所以某个数i的1的含1数量等于1（首位）+(i-p)的含1数量，p为与i位数相等的1000...0的十进制表示

1 #338
2 #Runtime: 52 ms (Beats 71.57%)
3 #Memory: 17.3 MB (Beats 36.53%)
4
5 class Solution(object):
6     def countBits(self, n):
7         """
8         :type n: int
9         :rtype: List[int]
10         """
11         ans = [1] * (n + 1)
12         ans[0] = 0
13         for i in range(1, n + 1):
14             if (i & (i-1)) == 0:
15                 p = i
16             else:
17                 ans[i] = 1 + ans[i - p]
18         return ans

Uriel 2023-09-03 15:51 发表评论

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

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

给出需要的skill list和每个人的skill，问最少需要其中的几个人可以满足skill list里面所有skill
二进制表示skill+DP，参考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]137. Single Number II (Medium) Python-2023.07.04

Uriel — Tue, 04 Jul 2023 16:36:00 GMT

一个数列，有一个数只出现1次，其他所有数都出现3次，找出出现1次的数
思路见9年前C++版本的记录->http://www.cppblog.com/Uriel/articles/205406.html

Python版（注意处理负数的情况，看了Discussion才意识到）

1 #137
2 #Runtime: 83 ms (Beats 39.2%)
3 #Memory: 14.8 MB (Beats 89.66%)
4
5 class Solution(object):
6     def singleNumber(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         ans = 0
12         for i in range(32):
13             cnt = 0
14             for m in nums:
15                 t = (m >> i) & 1
16                 cnt += t
17             cnt %= 3
18             if cnt and i == 31:
19                 ans -= 1 << 31
20             else:
21                 ans |= cnt << i
22         return ans

Uriel 2023-07-05 00:36 发表评论

[LeetCode]864. Shortest Path to Get All Keys (Hard) Python-2023.06.29

Uriel — Thu, 29 Jun 2023 14:27:00 GMT

给出一个二维迷宫，#代表墙，@代表起点，字母a-f代表钥匙，A-F代表对应的锁（如果先拿到了钥匙那么下次经过匹配的锁的时候那一格就可以走），.代表空地，问最少多少步可以拿到所有钥匙。
BFS，用位操作存储已经获得的钥匙情况，且同时记录已经走了几步

1 #864
2 #Runtime: 305 ms (Beats 78.95%)
3 #Memory: 19.6 MB (Beats 36.84%)
4
5 class Solution(object):
6     def shortestPathAllKeys(self, grid):
7         """
8         :type grid: List[str]
9         :rtype: int
10         """
11         nkey = 0
12         n, m = len(grid), len(grid[0])
13         d = [(0, 1), (1, 0), (0, -1), (-1, 0)]
14         for i in range(n):
15             for j in range(m):
16                 ch = grid[i][j]
17                 if ch == '@':
18                     sx, sy = i, j
19                 if 'a' <= ch <= 'f':
20                     nkey += 1
21         q = deque([(0, sx, sy)])
22         vis = defaultdict(bool)
23         vis[(0, sx, sy)] = True
24         stp = 0
25         while q:
26             sz = len(q)
27             while sz:
28                 sz -= 1
29                 ky, x, y = q.popleft()
30                 if ky == (1 << nkey) - 1:
31                     return stp
32                 for i in d:
33                     tx = x + i[0]
34                     ty = y + i[1]
35                     if 0 <= tx < n and 0 <= ty < m:
36                         tp_ky = ky
37                         ch = grid[tx][ty]
38                         if ch == '#':
39                             continue
40                         if 'a' <= ch <= 'f':
41                             tp_ky |= 1 << (ord(ch) - ord('a'))
42                         if 'A' <= ch <= 'F' and not (ky & (1 << (ord(ch) - ord('A')))):
43                             continue
44                         if not vis[(tp_ky, tx, ty)]:
45                             vis[(tp_ky, tx, ty)] = True
46                             q.append((tp_ky, tx, ty))
47             stp += 1
48         return -1

Uriel 2023-06-29 22:27 发表评论

[LeetCode]1318. Minimum Flips to Make a OR b Equal to c (Medium) Python-2023.06.07

Uriel — Wed, 07 Jun 2023 07:49:00 GMT

给出两个数a和b，问二进制表示下flip最少几个bit，可以使得a OR b = c，简单位运算（有参考Discussion的写法）

1 #1318
2 #Runtime: 27 ms (Beats 6.6%)
3 #Memory: 13.3 MB (Beats 78.79%)
4
5 class Solution(object):
6     def minFlips(self, a, b, c):
7         """
8         :type a: int
9         :type b: int
10         :type c: int
11         :rtype: int
12         """
13         ans = 0
14         for i in range(31):
15             if (c >> i) & 1:
16                 ans += ((a >> i) & 1) == 0 and ((b >> i) & 1) == 0
17             else:
18                 ans += (a >> i) & 1
19                 ans += (b >> i) & 1
20         return ans

Uriel 2023-06-07 15:49 发表评论

[LeetCode]645. Set Mismatch (Easy) Python-2022.10.23

Uriel — Sun, 23 Oct 2022 10:26:00 GMT

一列1-n的数，其中有一个重复的（意味着有一个数missing），找出重复了一次的数以及缺少的那个数

思路一：开个dict存每个数出现几次，再扫一遍找出duplicate和missing

1 #645
2 #Runtime: 447 ms
3 #Memory Usage: 15.5 MB
4
5 class Solution(object):
6     def findErrorNums(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         dict_num = {}
12         ans = [0, 0]
13         for i in nums:
14             if i not in dict_num:
15                 dict_num[i] = 1
16             else:
17                 dict_num[i] += 1
18         for i in range(1, len(nums) + 1):
19             if i not in dict_num:
20                 ans[1] = i
21             elif dict_num[i] > 1:
22                 ans[0] = i
23         return ans

思路二（看solution得到的启发，不使用其他dict等多余存储）：第一遍扫的时候将位于nums[abs(nums[i]) - 1]的数*-1，发现某个数已经是负的话说明duplicate，第二遍再扫一次，找出仍然大于0的数，其对应的下标就是missing的那个

1 #645
2 #Runtime: 495 ms
3 #Memory Usage: 14.2 MB
4
5 class Solution(object):
6     def findErrorNums(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         ans = [0, 0]
12         for i in range(len(nums)):
13             if nums[abs(nums[i]) - 1] < 0:
14                 ans[0] = abs(nums[i])
15             else:
16                 nums[abs(nums[i]) - 1] *= -1
17         for i in range(len(nums)):
18             if nums[i] > 0:
19                 ans[1] = i + 1
20         return ans

思路三（看solution得到的启发，异或思想，只用一重for循环，但需要一个dict）：原理：a^b^b=a

1 #645
2 #Runtime: 471 ms
3 #Memory Usage: 15.7 MB
4
5 class Solution(object):
6     def findErrorNums(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         dict_num = {}
12         ans = [0, 0]
13         for i in range(len(nums)):
14             if nums[i] not in dict_num:
15                 dict_num[nums[i]] = 1
16             else:
17                 ans[0] = nums[i]
18                 dict_num[nums[i]] += 1
19             ans[1] ^= (i + 1)
20             ans[1] ^= nums[i]
21         ans[1] ^= ans[0]
22         return ans

思路四（看solution得到的启发，异或思想，但实际只需要三重for循环，不需要额外dict），原理：a^b^b=a，找出a和b二进制最后一位出现不同的位置，将1-n分为两类，扫一遍nums和1-n之后，在其中一类会出现a，另一类出现b^b^b（=b），再扫一次nums就能找到b位于哪一类

1 #645
2 #Runtime: 306 ms
3 #Memory Usage: 14.8 MB
4
5 class Solution(object):
6     def findErrorNums(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         ans = [0, 0]
12         xor = 0
13         for i in range(len(nums)):
14             xor ^= (i + 1)
15             xor ^= nums[i]
16         rightmostbit = xor & ~(xor - 1)
17         for i in range(len(nums)):
18             if (i + 1) & rightmostbit != 0:
19                 ans[1] ^= (i + 1)
20             else:
21                 ans[0] ^= (i + 1)
22             if nums[i] & rightmostbit != 0:
23                 ans[1] ^= nums[i]
24             else:
25                 ans[0] ^= nums[i]
26         for i in nums:
27             if ans[0] == i:
28                 return ans
29         return [ans[1], ans[0]]

Uriel 2022-10-23 18:26 发表评论

[LeetCode]Single Number II-2014.01.16

Uriel — Wed, 15 Jan 2014 19:25:00 GMT

前一题的解题报告把这题的也说了。。一堆出现3次的数中找出唯一一个只出现了1次的，就是每位按位累加，然后mod 3，最后剩下的就是，但是WA了好多次，符号略搞。。

1 class Solution {
2 public:
3     int singleNumber(int A[], int n) {
4         unsigned int res = 0;
5         for(int j = 0; j < 32; ++j) {
6             int tp = 0;
7             const unsigned int pos = 1 << j;
8             for(int i = 0; i < n; ++i) {
9                 tp += (A[i] & pos) > 0;
10             }
11             res |= (!(tp % 3)) ? 0 : pos;
12         }
13         return (int)res;
14     }
15 };

另一种比较高大上的做法是开三个变量，分别标记出现过一次，两次，三次的，每处理一个数的时候分别计算异或、与、非[出现三次时前两个变量都为1，取反后利用第三个变量清除该数]，然后第一个变量中剩下的就是只出现过一次的数
代码巨优美~

1 class Solution {
2 public:
3     int singleNumber(int A[], int n) {
4         int tp3, tp1 = 0, tp2 = 0;
5         for(int i = 0; i < n; ++i) {
6             tp2 |= tp1 & A[i];
7             tp1 ^= A[i];
8             tp3 = ~(tp1 & tp2);
9             tp1 &= tp3;
10             tp2 &= tp3;
11         }
12         return tp1;
13     }
14 };

Uriel 2014-01-16 03:25 发表评论