61旋轉列表

被大多數人擊敗 不想寫題解

應該與我數了長度有關

我想的是這樣後面不用再遍歷了

很長時有利

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        
 
if k == 0:
            return head
        if head == None:
            return head
        header = ListNode(0,head)
        n = 0
        p = header
        q = header
        while p.next != None:
            n = n+1
            p = p.next
            if n > k:
                q = q.next
        
 
if n > k:
            p.next = header.next
            header.next = q.next
            q.next = None
            return header.next
        k = k%(n)
        if k == 0 :
            return head
        n = 0
        p = header
        q = header
        while p.next != None:
            n = n+1
            p 
 
= p.next
            if n > k:
                q = q.next
        p.next = header.next
        header.next = q.next
        q.next = None
        return header.next

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/rotate-list/solution/bei-duo-shu-ren-ji-bai-bu-xiang-xie-ti-j-ef8m/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

62：不同路徑

簡單的dp簡單的一天

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[0]*n for i in range(m)]
        for i in range(n):
            dp[m-1][i] = 1
        for i in range(m):
            dp[i][n-1] = 1
        for col in range(n-2,-1,-1):
            for row in range(m-2,-1,-1):
                dp[row][col] = dp[row+1][col] + dp[row][col+1]
        return dp[0][0]

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/unique-paths/solution/jian-dan-de-dp-jian-dan-de-yi-tian-by-yi-ypcr/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

63：

障礙不同路徑跟上題沒啥差別

遇到障礙就把障礙這裡變成0

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        dp = [[0]*n for i in range(m)]
        for i in range(n-1,-1,-1):
            if obstacleGrid[m-1][i] == 1:
                break
            dp[m-1][i] = 1
        for i in range(m-1,-1,-1):
            if obstacleGrid[i][n-1] == 1:
                break
            dp[i][n-1] = 1
        for col in range(n-2,-1,-1):
            for row in range(m-2,-1,-1):
                if obstacleGrid[row][col] == 1:
                    dp[row][col] = 0
                # elif dp[row+1][col] == 0 or  dp[row][col+1] == 0:
                #     dp[row][col] = 0
                else:
                    dp[row][col] = dp[row+1][col] + dp[row][col+1]
        return dp[0][0]


作者：yizhu-jia
連結：https://leetcode-cn.com/problems/unique-paths-ii/solution/jiu-shi-yu-dao-zhang-ai-jiu-ba-zhang-ai-twwhv/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

64 最小路徑和

一個解法寫三道題

又是被多數人擊敗的一天

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        dp = [[0]*n for i in range(m)]
        dp [m-1][n-1] = grid[m-1][n-1]
        for i in range(n-2,-1,-1):
            dp[m-1][i] = dp[m-1][i+1] + grid[m-1][i]
        for i in range(m-2,-1,-1):
            dp[i][n-1] = dp[i+1][n-1] + grid[i][n-1]
        for col in range(n-2,-1,-1):
            for row in range(m-2,-1,-1):
                    dp[row][col] = min(dp[row+1][col],dp[row][col+1])+grid[row][col]
        return dp[0][0]

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/minimum-path-sum/solution/yi-ge-jie-fa-xie-san-dao-ti-by-yizhu-jia-b82k/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

、

65有效數字

暴力解法

先看是不是小數（這裡整數也屬於小數）
再看有沒有e
有e看前面是不是小數 後面是不是整數

class Solution:
    def isNumber(self, s: str) -> bool:
        def isint(s1):          #看是不是整數 
            n = len(s1)
            if n == 0:           #0長不算整數
                return False
            if n == 1 and not s1[0].isnumeric():       #只有正負號 也不行
                return False
            flag = True
            if not (s1[0] == '+'
                    or s1[0] == '-'
                    or s1[0].isnumeric()):          #第一位必須是正負號數字中的一個
                flag = False
                return flag
            for each in s1[1:]:
                if not each.isnumeric():        #判斷後面的 如果都是數字 就是整數
                    flag = False
                    break
            return flag
        def isdec(s2):            #判斷是不是小數
            flag = 0
            for each in s2:
                if each.isnumeric():
                    flag =1
                    break                #必須存在一個數字才能是小數  全是符號不行 比如'.'  '+.'
            if not flag:
                return False
            if isint(s2):               #整數就是小數
                return True
            if '.' not in s2:        #不是整數 還沒有小數點？ 你是啥
                return False
            pos = s2.rfind('.')
            s21 = s2[0:pos]
            s22 = s2[pos+1:]              #拆成兩部分
            if not isint(s21) and len(s21)>0 and s21 != '+' and s21 != '-':     
                return False   #如果 前半部分不是空且不是整數且不是正負號  不用看後面了  
            if  len(s22) == 0:           
                return True            #如果後半部分是空 也滿足
            if  isint(s22) and s22[0].isnumeric():   #如果後半部分同時是不帶正負號的整數  說明是小數
                return True
            return False
        #主函式
        if 'e' in s and 'E' in s:    #Ee都在 再見
            return False
        if isdec(s):        #是小數  就是有效的
            return True
        if 'e' in s:           #找到e或者E的位置 找不到就再見
            pos = s.rfind('e')
        elif 'E' in s:
            pos = s.rfind('E')
        else:
            return False
        s1 = s[0:pos]
        s2 = s[pos+1:]               分割兩部分 前半部分是小數或者整數 後半部分是整數
        if isdec(s1) and isint(s2):
            return True
        return False


作者：yizhu-jia
連結：https://leetcode-cn.com/problems/valid-number/solution/bao-li-jie-fa-ji-bai-5cheng-ren-by-yizhu-3bvg/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

66加1

從後往前找到第一個不是9的 把他加一 如果全是9 就在第一位插入1 其他變0

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        i = len(digits)-1
        while i >= 0:
            if digits[i] != 9:
                digits[i] +=1
                return digits
            else:
                digits[i] = 0
            i -= 1
        digits.insert(0,1)
        return digits

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/plus-one/solution/cong-hou-wang-qian-zhao-dao-di-yi-ge-bu-1vk05/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

67 二進位制求和

暴力解

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        n1 = len(a)-1
        n2 = len(b)-1
        carry = 0
        rel = ''
        while n1 >= 0 or n2>=0:
            if n1 <0 :
                sum = int(b[n2]) +carry
            elif n2 <0:
                sum = int(a[n1]) +carry
            else:
                sum = int(a[n1])+int(b[n2]) +carry
            if sum == 0:
                rel += '0'
                carry = 0
            if sum == 1:
                rel += '1'
                carry = 0
            if sum == 2:
                rel += '0'
                carry = 1
            if sum == 3:
                rel += '1'
                carry = 1
            n1 -= 1
            n2 -= 1
        if carry == 1:
            rel += '1'
        return rel[::-1]

作者：yizhu-jia
連結：https://leetcode-cn.com/problems/add-binary/solution/-by-yizhu-jia-kegx/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。