LeetCode 每日一题 2021/9/20-2021/9/26

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

---

9/20 673. 最长递增子序列的个数

1.dp
dp[i] 记录i位置结尾的最长递增子序列长度
cnt[i] 记录i位置最长递增子序列个数
maxl记录最长递增子序列长度
ans记录个数
如果nums[i]>nums[j] 为递增
判断dp[j]+1是否大于dp[i] 如果大于 则nums[j]->nums[i]为当前最长递增子序列
记录长度dp[i]=dp[j]+1 更新个数cnt[i]=cnt[j]
如果dp[j]+1等于dp[i] 增加个数cnt[i]+=cnt[j]

def findNumberOfLIS(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    maxl,n=0,len(nums)
    ans = 0
    dp=[0]*n
    cnt=[0]*n
    for i in range(n):
        dp[i]=1
        cnt[i]=1
        for j in range(i):
            if nums[i]>nums[j]:
                if dp[j]+1>dp[i]:
                    dp[i] = dp[j]+1
                    cnt[i] = cnt[j]
                elif dp[j]+1==dp[i]:
                    cnt[i]+=cnt[j]
        if dp[i]>maxl:
            maxl=dp[i]
            ans = cnt[i]
        elif dp[i]==maxl:
            ans+=cnt[i]
    return ans

---

9/21 最后一个单词的长度

从后往前判断 跳过连续的空格
记录字符后 遇到空格及退出

def lengthOfLastWord(s):
    """
    :type s: str
    :rtype: int
    """
    n = len(s)
    space = True
    ans = 0
    for i in range(n-1,-1,-1):
        if s[i]==" " and space:
            continue
        elif s[i]!=" ":
            space = False
            ans +=1
        else:
            break
    return ans

---

9/22 725. 分隔链表

分解质因数
如果是质数 则只能一个个复制粘贴
合数分解成质数 a = b*c 那么a需要b+c次操作

def minSteps(n):
    """
    :type n: int
    :rtype: int
    """
    ans = 0
    i = 2
    while i*i<=n:
        while n%i==0:
            n //=i
            ans +=i
        i+=1
    if n>1:
        ans +=n
    return ans

---

9/23 326. 3的幂

不断除以3 出现余数说明不满足

def isPowerOfThree(n):
    """
    :type n: int
    :rtype: bool
    """
    while n>1:
        if n%3==0:
            n=n//3
        else:
            return False
    return True if n==1 else False

---

9/24 430. 扁平化多级双向链表

递归
记录下一个节点next
如果有子节点
则判断子节点 返回头结点
将子节点返回的头节点接在后面
移动到最后 接刚才的next

def flatten(head):
    """
    :type head: Node
    :rtype: Node
    """
    def find(node):
        curr = node
        
        while curr:
            net = curr.next
            if curr.child:
                tail = find(curr.child)
                curr.child = None
                curr.next = tail
                tail.prev = curr
                while curr.next:
                    curr = curr.next
                curr.next = net
                if net:
                    net.prev = curr
            curr = curr.next
            
        return node

    return find(head)

---

9/25 583. 两个字符串的删除操作

dp
dp[i][j] 代表word1[:i] word2[:j] 需要的删除操作
对于dp[x][0] dp[0][x]操作必定是x次
如果word1[i]与word2[j]相等
那么删除操作没有增长 dp[i][j] = dp[i-1][j-1]
否则删除操作增长1 min(dp[i-1][j],dp[i][j-1])+1

def minDistance(word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        """
        n,m = len(word1),len(word2)
    
        dp = [[0]*(m+1) for _ in range(n+1)]
        for i in range(1,n+1):
            dp[i][0]=i
        for j in range(1,m+1):
            dp[0][j]=j
        
        for i in range(1,n+1):
            for j in range(1,m+1):
                if word1[i-1]==word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j],dp[i][j-1])+1
        return dp[n][m]

---

9/26 371. 两整数之和

异或模拟相加的结果 相与移位模拟进位

def getSum(a, b):
    """
    :type a: int
    :type b: int
    :rtype: int
    """
    while b!=0:
        print(b)
        if b == 2**32:
            return a^(-2**32)
        carry = (a&b)
        a = a^b
        b = carry<<1
    return a

---