给你一个整数数组 nums，请你返回该数组中恰有四个因数的这些整数的各因数之和。如果数组中不存在满足题意的整数，则返回 0 。
func sumFourDivisors(nums []int) int {
var ans int
for _, num := range nums {
var count int
var pre int
for i := 1; i*i <= num; i++ {
if num%i == 0 {
count += 2
pre += i + num/i
}
if count > 4 {
break
}
if i*i == num {
count--
}
}
if count == 4 {
ans += pre
}
}
return ans
}给你一个 n x n 的整数方阵 matrix 。你可以执行以下操作 任意次 ：
- 选择
matrix中 相邻 两个元素，并将它们都 乘以-1。
如果两个元素有 公共边 ，那么它们就是 相邻 的。
你的目的是 最大化 方阵元素的和。请你在执行以上操作之后，返回方阵的 最大 和。
示例 1：
输入：matrix = [[1,-1],[-1,1]]
输出：4
解释：我们可以执行以下操作使和等于 4 ：
- 将第一行的 2 个元素乘以 -1 。
- 将第一列的 2 个元素乘以 -1 。示例 2：
输入：matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]
输出：16
解释：我们可以执行以下操作使和等于 16 ：
- 将第二行的最后 2 个元素乘以 -1 。func maxMatrixSum(matrix [][]int) int64 {
var sum int
var count int
var minVal int = math.MaxInt
for row := range matrix {
for col := range matrix[row] {
if matrix[row][col] < 0 {
count++
minVal = min(minVal, -(matrix[row][col]))
sum += -matrix[row][col]
} else {
minVal = min(minVal, (matrix[row][col]))
sum += matrix[row][col]
}
}
}
if count%2 == 1 {
return int64(sum) - int64(minVal)*2
}
return int64(sum)
}给你一个二叉树的根节点 root。设根节点位于二叉树的第 1 层，而根节点的子节点位于第 2 层，依此类推。
返回总和 最大 的那一层的层号 x。如果有多层的总和一样大，返回其中 最小 的层号 x。
示例 1：
输入：root = [1,7,0,7,-8,null,null]
输出：2
解释：
第 1 层各元素之和为 1，
第 2 层各元素之和为 7 + 0 = 7，
第 3 层各元素之和为 7 + -8 = -1，
所以我们返回第 2 层的层号，它的层内元素之和最大。func maxLevelSum(root *TreeNode) int {
var dfs func(deep int, root *TreeNode)
sum := []int{}
dfs = func(deep int, root *TreeNode) {
if root == nil {
return
}
if len(sum) == deep {
sum = append(sum, root.Val)
} else {
sum[deep] += root.Val
}
dfs(deep+1, root.Left)
dfs(deep+1, root.Right)
}
dfs(0, root)
var ans int
for k, s := range sum {
if s > sum[ans] {
ans=k
}
}
return ans+1
}给你一棵二叉树，它的根为 root 。请你删除 1 条边，使二叉树分裂成两棵子树，且它们子树和的乘积尽可能大。
由于答案可能会很大，请你将结果对 10^9 + 7 取模后再返回。
示例 1：
输入：root = [1,2,3,4,5,6]
输出：110
解释：删除红色的边，得到 2 棵子树，和分别为 11 和 10 。它们的乘积是 110 （11*10）示例 2：
输入：root = [1,null,2,3,4,null,null,5,6]
输出：90
解释：移除红色的边，得到 2 棵子树，和分别是 15 和 6 。它们的乘积为 90 （15*6）//超时版：
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func maxProduct(root *TreeNode) int {
var total int
var dfs func(root *TreeNode)
dfs = func(root *TreeNode) {
if root == nil {
return
} else {
total += root.Val
dfs(root.Left)
dfs(root.Right)
}
}
dfs(root)
var dfs_2 func(root *TreeNode) int
dfs_2 = func(root *TreeNode) int {
if root == nil {
return 0
} else {
return root.Val + dfs_2(root.Left) + dfs_2(root.Right)
}
}
var ans int
var dfs_3 func(root *TreeNode)
dfs_3 = func(root *TreeNode) {
if root == nil {
return
} else {
left := dfs_2(root.Left)
right := dfs_2(root.Right)
ans = max(ans, (total-left)*left, (total-right)*right)
dfs_3(root.Left)
dfs_3(root.Right)
}
}
dfs_3(root)
return ans %1_000_000_007
}func maxProduct(root *TreeNode) int {
var total int
var dfs func(root *TreeNode)
dfs = func(root *TreeNode) {
if root == nil {
return
} else {
total += root.Val
dfs(root.Left)
dfs(root.Right)
}
}
dfs(root)
var dfs_2 func(root *TreeNode) int
var ans int
dfs_2 = func(root *TreeNode) int {
if root == nil {
return 0
}
s := root.Val + dfs_2(root.Left) + dfs_2(root.Right)
ans = max(ans, (total-s)*s)
return s
}
dfs_2(root)
return ans % 1_000_000_007
}