LeetCode 每日一题 2022/8/1-2022/8/7

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

---

8/1 1374. 生成每种字符都是奇数个的字符串

n是奇数 则n个a
n是偶数 则n-1个a 1个b

def generateTheString(n):
    """
    :type n: int
    :rtype: str
    """
    s = "a"*(n-1)
    if n%2==1:
        s+="a"
    else:
        s+="b"
    return s


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

---

8/2 622. 设计循环队列

使用队列模拟 head,tail分别记录当前头尾位置
num记录当前队列中有用的个数

class MyCircularQueue(object):

    def __init__(self, k):
        """
        :type k: int
        """
        self.q = [-1]*k
        self.head = 0
        self.tail = 0
        self.num = 0
        self.k = k


    def enQueue(self, value):
        """
        :type value: int
        :rtype: bool
        """
        if self.num<self.k:
            self.q[self.tail] = value
            self.tail = (self.tail+1)%self.k
            self.num +=1
            return True
        else:
            return False


    def deQueue(self):
        """
        :rtype: bool
        """
        if self.num>0:
            self.num -=1
            self.head = (self.head+1)%self.k
            return True
        else:
            return False


    def Front(self):
        """
        :rtype: int
        """
        if self.num>0:
            return self.q[self.head]
        else:
            return -1


    def Rear(self):
        """
        :rtype: int
        """
        if self.num>0:
            loc = self.tail-1
            if loc<0:
                loc += self.k
            return self.q[loc]
        else:
            return -1


    def isEmpty(self):
        """
        :rtype: bool
        """
        return self.num==0


    def isFull(self):
        """
        :rtype: bool
        """
        return self.num == self.k


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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

---

8/3 899. 有序队列

当k>1时 可以得到s的升序字符串
当k=1时 需要考虑移动n-1次的每种情况

def orderlyQueue(s, k):
    """
    :type s: str
    :type k: int
    :rtype: str
    """
    if k>1:
        return "".join(sorted(s))
    ans = s
    for i in range(1,len(s)):
        tmp = s[i:]+s[:i]
        if tmp<ans:
            ans = tmp
    return ans

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

---

8/4 1403. 非递增顺序的最小子序列

先求总和
从大到小排序
依次取出较大的数 直至超过总和的一半

def minSubsequence(nums):
    """
    :type nums: List[int]
    :rtype: List[int]
    """
    nums.sort(reverse=True)
    total = sum(nums)
    ans = []
    cur = 0
    for num in nums:
        cur += num
        ans.append(num)
        if cur>total/2:
            break
    return ans


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

---

8/5 623. 在二叉树中增加一行

dfs找到这一层之前一层 加入
如果depth=1特殊处理

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def addOneRow(root, val, depth):
    """
    :type root: TreeNode
    :type val: int
    :type depth: int
    :rtype: TreeNode
    """
    def dfs(node,d):
        if not node:
            return 
        if d==depth:
            l = TreeNode(val)
            l.left = node.left
            node.left = l
            r = TreeNode(val)
            r.right = node.right
            node.right = r
            return
        dfs(node.left,d+1)
        dfs(node.right,d+1)
        return
    if depth==1:
        new = TreeNode(val)
        new.left = root
        return new
    dfs(root,1)
    return root


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
29
30
31
32
33
34
35

---

8/6 1408. 数组中的字符串匹配

穷举 两两比较

def stringMatching(words):
    """
    :type words: List[str]
    :rtype: List[str]
    """
    ans = []
    for i,x in enumerate(words):
        for j,y in enumerate(words):
            if i!=j and x in y:
                ans.append(x)
                break
    return ans


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

---

8/7 636. 函数的独占时间

栈 保存[函数标签，起始时间]信息
如果是起始点 判断栈中是否有元素
如果有 说明上一个暂时暂停了 中间间隔为上一个元素的时间
并将上个元素起始点移至当前位置
将当前元素信息保存
如果是终结点 则与上一个起始点配对 将间隔时间加入
此时如果栈中还有元素 将其起始位移至当前位置

def exclusiveTime(n, logs):
    """
    :type n: int
    :type logs: List[str]
    :rtype: List[int]
    """
    ans = [0]*n
    st = []
    for log in logs:
        l = log.split(":")
        idx,tg,time = int(l[0]),l[1],int(l[2])
        if tg=="start":
            if st:
                tmpid,tmptime = st[-1]
                ans[tmpid]+=time-tmptime
                st[-1][1] = time            
            st.append([idx,time])
        else:
            i,t = st.pop()
            ans[i]+=time-t+1
            if st:
                st[-1][1] = time+1
    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

---