LeetCode 每日一题 2026/1/5-2026/1/11

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

---

目录

• • • [1/5 1975. 最大方阵和](#1/5 1975. 最大方阵和)
    • [1/6 1161. 最大层内元素和](#1/6 1161. 最大层内元素和)
    • [1/7 1339. 分裂二叉树的最大乘积](#1/7 1339. 分裂二叉树的最大乘积)
    • [1/8 1458. 两个子序列的最大点积](#1/8 1458. 两个子序列的最大点积)
    • [1/9 865. 具有所有最深节点的最小子树](#1/9 865. 具有所有最深节点的最小子树)
    • 1/10
    • 1/11

1/5 1975. 最大方阵和

如果有偶数个负数 经过若干次操作可以将他们变为正

如果有奇数个负数 最后会剩下一个负数 将绝对值最小的为负数 可以使得和最大

遍历

def maxMatrixSum(matrix):
    """
    :type matrix: List[List[int]]
    :rtype: int
    """
    minv = float('inf')
    ans = 0
    nums = 0
    for i in range(len(matrix)):
        for j in range(len(matrix[0])):
            v = matrix[i][j]
            if v<0:
                nums+=1
                v=-v
            ans+=v
            minv=min(minv,v)
    if nums%2:
        ans-=2*minv
    return ans

---

1/6 1161. 最大层内元素和

遍历每一层 计算每一层元素和s

cur为当前最大元素和 ans为最大元素和所在层数

num记录当前层数

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def maxLevelSum(root):
    """
    :type root: Optional[TreeNode]
    :rtype: int
    """
    cur=root.val
    ans = 1
    l=[root]
    num=1
    while l:
        tmp=[]
        s=0
        for node in l:
            if node.left:
                tmp.append(node.left)
            if node.right:
                tmp.append(node.right)
            s+=node.val
        if s>cur:
            cur=s
            ans=num
        num+=1
        l=tmp
    return ans

---

1/7 1339. 分裂二叉树的最大乘积

先统计所有节点和 s

再一次遍历所有子树和sub 判断sub*(s-sub)

sub越接近s//2 乘积越大 存储最接近一半的值

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def maxProduct(root):
    """
    :type root: Optional[TreeNode]
    :rtype: int
    """
    MOD=10**9+7
    global s,target
    s=0
    target=0
    
    def calculatesum(node):
        global s
        if not node:
            return 
        s+=node.val
        calculatesum(node.left)
        calculatesum(node.right)
        
    calculatesum(root)
    
    def dfs(node):
        global target,s
        if not node:
            return 0
        cur = dfs(node.right)+dfs(node.left)+node.val
        if abs(cur*2-s)<abs(target*2-s):
            target=cur
        return cur
    dfs(root)
    return target*(s-target)%MOD

---

1/8 1458. 两个子序列的最大点积

动归

def maxDotProduct(nums1, nums2):
    """
    :type nums1: List[int]
    :type nums2: List[int]
    :rtype: int
    """
    m,n=len(nums1),len(nums2)
    dp=[[0]*n for _ in range(m)]
    
    for i in range(m):
        for j in range(n):
            v = nums1[i]*nums2[j]
            dp[i][j]=v
            if i>0:
                dp[i][j]=max(dp[i][j],dp[i-1][j])
            if j>0:
                dp[i][j]=max(dp[i][j],dp[i][j-1])
            if i>0 and j>0:
                dp[i][j]=max(dp[i][j],dp[i-1][j-1]+v)
    return dp[m-1][n-1]

---

1/9 865. 具有所有最深节点的最小子树

bfs遍历一遍获得最深深度 并记录每个节点的深度 和 最深深度d

check深搜 判断左右子树包含的最深深度

如果当前node两个子树最深深度都是d 那么这个node为最小子树

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        
def subtreeWithAllDeepest(root):
    """
    :type root: Optional[TreeNode]
    :rtype: Optional[TreeNode]
    """
    global ans
    ans = root
    m={}
    l=[root]
    d = 0
    while l:
        d+=1
        tmp=[]
        for node in l:
            m[node.val]=d
            if node.left:
                tmp.append(node.left)
            if node.right:
                tmp.append(node.right)
        l=tmp
    
    def check(node):
        global ans
        l,r=m[node.val],m[node.val]
        if node.left:
            l = check(node.left)
        if node.right:
            r = check(node.right)
        if l==r and l==d:
            ans = node
        return max(l,r)
    check(root)
    return ans

---

1/10

---

1/11

---