lc marathon 8.2

622. 设计循环队列

循环队列，若需要存k个元素，则申请k+1个空间，并留出最后一位。

front 队头只删除元素

rear 队尾只插入元素

front 指向队头第一个元素

rear 指向队尾第一个空的位置(最后一个元素的后一位)

front==rear 队空

front==(rear+1)%(k+1) 队满

删除 需检查是否队空

插入 需检查是否队满

class MyCircularQueue:

    def __init__(self, k: int):
        self.front=0
        self.rear=0
        self.ls=[0 for i in range(k+1)]
        self.maxlen=k+1
        

    def enQueue(self, value: int) -> bool:
        if self.front%self.maxlen==(self.rear+1)%self.maxlen:
            return False
        self.ls[self.rear%self.maxlen]=value
        self.rear=(self.rear+1)%self.maxlen
        return True


    def deQueue(self) -> bool:
        if self.front==self.rear:
            return False
        self.front=(self.front+1)%self.maxlen
        return True


    def Front(self) -> int:
        if self.rear==self.front:
            return -1
        return self.ls[self.front%self.maxlen]

    def Rear(self) -> int:
        if self.rear==self.front:
            return -1
        return self.ls[(self.rear-1)%self.maxlen]

    def isEmpty(self) -> bool:
        if self.front==self.rear:
            return True
        else:
            return False


    def isFull(self) -> bool:
        if self.front%self.maxlen==(self.rear+1)%self.maxlen:
            return True
        else:
            return False
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

222. 完全二叉树的节点个数

利用完全二叉树的性质，满二叉树的节点数==2^height-1

因此我们先检查是不是满二叉树 ，是的话可以直接算

不是，则再分别递归左右节点

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if root==None:
            return 0
        left=root.left
        ld=1
        right=root.right
        rd=1
        while(left):
            ld=ld+1
            left=left.left
        while(right):
            rd=rd+1
            right=right.right
        if ld==rd:
            return pow(2,ld)-1
        return 1+self.countNodes(root.left)+self.countNodes(root.right)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

357. 统计各位数字都不同的数字个数

get1 求n的阶乘

get2 求n位的时候，有几种

用排列组合的知识

n=1:0,1,2,3…9 共有10种

dic={}
class Solution:
    def countNumbersWithUniqueDigits(self, n: int) -> int:
       
        if n>10:
            return 0
        if n==0:
            return 1
        s=0
        for i in range(1,n+1):
            s+=get2(i)
        return int(s)
def get2(n):
        # 全部不相同
        # n>10:return 0
        # n=10:return A{10}{10}-A{9}{9}
        # n<10:
        # 首先从10个数字中 挑选n个 C{n}{10}
        # 然后对其排序  A{n}{n}
        # 最终结果减去  0开头的数字  C{9}{n-1}*A{n-1}{n-1}
    if n>10 :
        return 0
    elif n==10:
        return get(n)-get(n-1)
    elif n==1:
        return 10
    else:
        return get(10)/get(10-n)-get(9)/get(9-n+1)
            
        # 1:0,1,2,3,4..9
def get(n):
    global dic
    if n in dic.keys():
        return dic[n]
    l=1
    for i in range(1,n+1):
        l=l*i
    dic[n]=l
    return l
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

205. 同构字符串

要求必须长度一样，元素种类个数一样

且相同的位置 一样

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        if not  (len(s)==len(t) and len(set(s))==len(set(t))):
            return False
        dic={}
        for index,schar in enumerate(s):
            if schar not in dic.keys():
                dic[schar]=index
            else:
                if t[index]!=t[dic[schar]]:
                    return False
        return True
1
2
3
4
5
6
7
8
9
10
11
12