leetcode刷题记录1071-1080 python版

前言

继续leetcode刷题生涯
这里记录的都是笔者觉得有点意思的做法
参考了好几位大佬的题解，感谢各位大佬

1071. 字符串的最大公因子

class Solution:
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        if str1 + str2 != str2 + str1: return ""
        m, n = len(str1), len(str2)
        def gcd(a, b):
            return a if b == 0 else gcd(b, a % b)
        return str1[:gcd(m, n)]
# 一行
class Solution:
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        return str1[:math.gcd(len(str1), len(str2))] if str1 + str2 == str2 + str1 else ""

1072. 按列翻转得到最大值等行数

class Solution:
    def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
        dic = dict()
        res = 0
        for row in matrix:
            if row[0] == 1:
                tmp = tuple(1-x for x in row)
            else:
                tmp = tuple(row)
            if tmp in dic:
                dic[tmp] += 1
            else:
                dic[tmp] = 1
        for count in dic.values():
            res = max(res, count)
        return res

1073. 负二进制数相加

class Solution:
    def addNegabinary(self, arr1: List[int], arr2: List[int]) -> List[int]:
        num1=0
        for i,num in enumerate(arr1[::-1]):
            num1+=num*(-2)**i
        num2 = 0
        for i,num in enumerate(arr2[::-1]):
            num2+=num*(-2)**i
        sumnum = num1+num2
        res =[]
        while sumnum!=1 and sumnum!=0:
            if sumnum%(-2)==0:
                res.append(0)
                sumnum = sumnum//(-2)
            else:
                if sumnum>0:
                    res.append(1)
                    sumnum = (sumnum//2)*-1
                else:
                    res.append(1)
                    sumnum = (sumnum-1)//(-2)
        res.append(sumnum)
        return res[::-1]

1074. 元素和为目标值的子矩阵数量

class Solution:
    def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
        m = len(matrix)
        n = len(matrix[0])
        res = 0
        for i in range(m):
            sum_item = [0] * n
            for j in range(i, m):
                s = 0
                dct = dict()
                dct[0] = 1
                for k in range(n):
                    sum_item[k] += matrix[j][k]
                    s += sum_item[k]
                    res += dct.get(s-target, 0)
                    dct[s] = dct[s] + 1 if s in dct else 1
        return res

1078. Bigram 分词

class Solution:
    def findOcurrences(self, text: str, first: str, second: str) -> List[str]:
        word_lst = text.split()
        res = []
        n = len(word_lst)
        for i in range(1,n):
            if word_lst[i-1] == first  and word_lst[i] == second and i+1<n:
                res.append(word_lst[i+1])
        return res

1079. 活字印刷

class Solution:
    def numTilePossibilities(self, tiles: str) -> int:
        res = set()
        def helper(tmp,tiles):
            if tmp:
                res.add(tmp)
            for i in range(len(tiles)):
                helper(tmp+tiles[i],tiles[:i]+tiles[i+1:])
        helper('',tiles)
        return len(res)

1080. 根到叶路径上的不足节点

class Solution:
    def sufficientSubset(self, root: TreeNode, limit: int) -> TreeNode:
        head = TreeNode(0)
        head.left = root

        def dfs(node: TreeNode, sums):
            if not node: return 0
            left = dfs(node.left, sums + node.val)
            right = dfs(node.right, sums + node.val)
            sub_sum = 0
            if node.left and node.right:
                sub_sum = max(left, right)
            elif node.left:
                sub_sum = left
            elif node.right:
                sub_sum = right
            if sums + node.val + left < limit:
                node.left = None
            if sums + node.val + right < limit:
                node.right = None
            return node.val + sub_sum

        dfs(head, 0)
        return head.left