【力扣每日一题】每日一题Python代码详解【持续更新】

34.在排序数组中查找元素的第—个和最后一个位置

不考虑时间空间的情况下，用python的index函数与reserve函数可以很简单的写出这一题：

class Solution(object):
    def searchRange(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        self = []
        if target not in nums:
            self = [-1, -1]
            return self
        else:
            self.append(nums.index(target))
            nums.reverse() # 翻转nums
            self.append(len(nums) - 1 - nums.index(target))    
            return self

861.翻转后矩阵的得分

代码详解如下：

class Solution(object):
    def matrixScore(self, A):
        """
        :type A: List[List[int]]
        :rtype: int
        """
        
        m = len(A) #行数
        n = len(A[0]) #列数
        # 第一步，先将二维列表第一列数值不是1的行进行行变化，将第一列全部变成1
        for i in range(m):
            if A[i][0] != 1:
                for j in range(n):
                    if A[i][j] == 1:
                        A[i][j] = 0
                    else:
                        A[i][j] = 1     
        # 第二步，依次遍历每一列，如果某一列的1的数量少于0，则将这一列翻转                  
        for i in range(1, n):
            temp = 0
            for j in range(m):
                if A[j][i] == 1:
                    temp += 1
            if temp < (m//2 + 1): # 这里可以改成temp < m/2,但是力扣m/2不支持浮点数，所以用这个形式
                for j in range(m):
                    if A[j][i] == 1:
                        A[j][i] = 0
                    else:
                        A[j][i] = 1
        # 第三步，依次遍历每一行，按照二进制的方式取值，把每一行相加
        num = 0 #最终返回的值
        temp = 0 #暂存每一行的二进制对应的值
        for i in range(m):
            temp = 1
            for j in range(n):
                if A[i][j] == 1:
                    temp = 2 ** (n-j-1)
                    num += temp
        return num

62.不同路径

动态规划

从图片可以看出
递推公式是：dp[i][j] = dp[i-1][j] + dp[i][j-1]
而第一行的任何位置都只有一条路径，在第一列的任何位置也都只有一条路径，所以边界条件是第一行和第一列都是1。

m = 3 # 行
n = 7 # 列
dp = [[0 for i in range(n)] for i in range(m)]
# 这里注意二维列表的创建方法，n表示列，m表示行，不能搞反，否则后面会越界
for i in range(m):
    dp[i][0] = 1
for i in range(n):
    dp[0][i] = 1
# 上面俩个for循环用来确定边界条件

for i in range(1, m):
    for j in range(1, n):
        dp[i][j] = dp[i-1][j] + dp[i][j-1] #递推公式
print(dp[m-1][n-1]) # 返回最后一个位置的值，即路径条数

649.参议院：

思路参考：https://leetcode-cn.com/problems/dota2-senate/solution/649-dota2-can-yi-yuan-tan-xin-suan-fa-ji-siha/

class Solution(object):
    def predictPartyVictory(self, senate):
        """
        :type senate: str
        :rtype: str
        """
        flag = 0 # flag > 0 则R多于D，反之R少于D
        R = True
        D = True
        while(R & D):
            R = False
            D = False
            for i in senate:
                if i == 'R':
                    if flag < 0: i = 0
                    else: R = True
                    flag += 1
                if i == 'D':
                    if flag > 0: i = 0
                    else: D = True
                    flag -= 1
        
        if R:
            return "Radiant"
        else:
            return "Dire"

860.柠檬水找零

class Solution(object):
    def lemonadeChange(self, bills):
        """
        :type bills: List[int]
        :rtype: bool
        """
        list1 = 0
        list2 = 0
        list3 = 0
        for i in bills:
            if i == 5:
                list1 += 1
            if (list1 * 5 + list2 * 10 + list3 * 20) < i - 5:
                return False
            else:
                if i == 10:
                    if list1 != 0:
                        list1 -= 1
                        list2 += 1          
                    else:
                        return False
                elif i == 20:
                    if (list2 != 0) & (list1 != 0):
                        list1 -= 1
                        list2 -= 1
                        list3 += 1
                    elif (list2 == 0) & (list1 >= 3):
                        list1 -= 3
                        list3 += 1
                    else:
                        return False

        return True

49.字母异位词分组

用字典键值对的对应来完成此题
先定义一个值类型为列表的字典
然后将每一个字符串排序之后与字典的键对应
对应相同键的字符串放在同一个值内

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        dict = defaultdict(list) # defaultdict()可以用来初始化一个值为列表的字典
        for st in strs:
            key = ''.join(sorted(st))
            dict[key].append(st)

        return list(dict.values()) # 可以将字典的所有值以列表的形式输出出来

738:单调递增的数字

class Solution(object):
    def monotoneIncreasingDigits(self, N):
        """
        :type N: int
        :rtype: int
        """
        newN = str(N)
        flag = len(newN)
        # flag 用来记录从哪个位置开始把从这个位置到结尾都变成9
        for i in range(len(newN)-1, 0, -1):
            if newN[i-1] > newN[i]:
                flag = i
                temp = int(newN[i-1]) - 1
                newN = newN[:i-1] + str(temp) + newN[i:]
                # 字符串修改数值必须用切割序列的方法，不能直接修改
            for j in range(flag, len(newN), 1):
                newN = newN[:j] + '9' + newN[j+1:]
        return(int(newN))