LeetCode 每日一题 2023/10/16-2023/10/22

记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步

---

10/16 260. 只出现一次的数字 III

有两个数不同 那么求取所有数的异或xor 等于不同的两个数a,b的异或
因为a!=b那么xor至少有一位等于1 而在这一位上a,b中一个等于0，一个等于1
所以可以将所有数根据这一位是否等于1 分为两组 一组包含了a,另一组包含了b
那么对这两组的数取分别都异或 一组为a 一组为b

def singleNumber(nums):
    """
    :type nums: List[int]
    :rtype: List[int]
    """
    xor,a,b,mask=0,0,0,1
    for num in nums:
        xor ^=num
    while xor&mask==0:
        mask<<=1
    for num in nums:
        if num&mask:
            a ^=num
        else:
            b ^=num
        
    return [a,b]


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

10/17 2652. 倍数求和

枚举

def sumOfMultiples(n):
    """
    :type n: int
    :rtype: int
    """
    ans = 0
    for i in range(1,n+1):
        if i%3==0 or i%5==0 or i%7==0:
            ans+=i
    return ans


1
2
3
4
5
6
7
8
9
10
11
12

---

10/18 2530. 执行 K 次操作后的最大分数

最大堆每次从中取出最大的值进行操作

def maxKelements( nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: int
    """
    import heapq
    l = [-x for x in nums]
    heapq.heapify(l)
    ans = 0
    for i in range(k):
        v  = -heapq.heappop(l)
        ans +=v
        heapq.heappush(l,-((v+2)//3))
    return ans



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

10/19 1726. 同积元组

统计出两两相乘积的所有情况
如果两组数积相同可以有八个元组

def tupleSameProduct(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    nums.sort()
    ans = 0
    m={}
    n = len(nums)
    for i in range(n-1):
        for j in range(i+1,n):
            v = nums[i]*nums[j]
            m[v] = m.get(v,0)+1
    for v in  m.values():
        ans += (v*(v-1)//2)*8
    return ans


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

10/20 2525. 根据规则将箱子分类

分别判断体积和质量

def categorizeBox(length, width, height, mass):
    """
    :type length: int
    :type width: int
    :type height: int
    :type mass: int
    :rtype: str
    """
    if length>=10**4 or width>=10**4 or height>=10**4 or length*width*height>=10**9:
        if mass>=100:
            return "Both"
        else:
            return "Bulky"
    else:
        if mass>=100:
            return "Heavy"
        else:
            return "Neithger"



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

---

10/21 2316. 统计无向图中无法互相到达点对数

dfs找出每个区域中的个数 将这个个数与之前区域的相乘

def countPairs(n, edges):
    """
    :type n: int
    :type edges: List[List[int]]
    :rtype: int
    """
    g = [[] for _ in range(n)]
    for a,b in edges:
        g[a].append(b)
        g[b].append(a)
        
    mem=[False]*n
    
    def dfs(v):
        if mem[v]:
            return 0
        mem[v]=True
        return 1+sum(dfs(i) for i in g[v])
    
    ans = 0
    pre = 0
    for i in range(n):
        cur = dfs(i)
        ans += cur*pre
        pre += cur
    return ans


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

---

10/22 1402. 做菜顺序

从大到小排序 每次加前缀和
直到前缀和小于0

def maxSatisfaction(satisfaction):
    """
    :type satisfaction: List[int]
    :rtype: int
    """
    satisfaction.sort(reverse=True)
    ans = 0
    s = 0
    for v in satisfaction:
        s+=v
        if s<=0:
            break
        ans +=s
    return ans



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---