这是 LeetCode 2321「拼接数组的最大分数」的 Go 语言实现：
```go
func maximumsSplicedArray(nums1 []int, nums2 []int) int {
n := len(nums1)
sum1, sum2 := 0, 0
diff := make([]int, n)
// 计算两个数组的总和及差值数组
for i := 0; i < n; i++ {
sum1 += nums1[i]
sum2 += nums2[i]
diff[i] = nums2[i] - nums1[i]
}
// 情况1：从nums2中选一段替换到nums1
maxGain1 := maxSubarraySum(diff) // 最大子数组和
// 情况2：从nums1中选一段替换到nums2
// 等价于求 diff 的相反数的最大子数组和
maxGain2 := maxSubarraySum(negate(diff))
// 取两种方案的最大值
return max(sum1+maxGain1, sum2+maxGain2)
}
// 最大子数组和（Kadane算法，允许空子数组，最小为0）
func maxSubarraySum(arr []int) int {
curr, best := 0, 0
for _, val := range arr {
curr += val
if curr < 0 {
curr = 0
}
if curr > best {
best = curr
}
}
return best
}
// 返回数组的相反数
func negate(arr []int) []int {
res := make([]int, len(arr))
for i, v := range arr {
res[i] = -v
}
return res
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
```
核心思路：
1. 问题转化：交换一段子数组相当于计算差分数组的最大子段和
· 定义 diff[i] = nums2[i] - nums1[i]
· 将 nums2 的一段替换到 nums1，增益为 sum(diff[l..r])
· 将 nums1 的一段替换到 nums2，相当于 diff 取反后再求最大子段和
2. 算法步骤：
· 计算 sum1、sum2 和 diff 数组
· 用 Kadane 算法求 diff 的最大子段和（允许空子段，最小为0）
· 同理求 -diff 的最大子段和
· 答案 = max(sum1+增益1, sum2+增益2)
3. 复杂度：O(n) 时间，O(n) 额外空间（diff 数组可优化为 O(1) 空间）
package main
func maximumsSplicedArray(nums1 []int, nums2 []int) int {
n := len(nums1)
sum1, sum2 := 0, 0
diff := make([]int, n)
for i := 0; i < n; i++ {
sum1 += nums1[i]
sum2 += nums2[i]
diff[i] = nums2[i] - nums1[i]
}
// 计算最大子段和（允许空子段，即至少为0）
maxGain1 := maxSubarraySum(diff) // 对nums1的增益
maxGain2 := maxSubarraySum(neg(diff)) // 对nums2的增益
ans := sum1 + maxGain1
if sum2+maxGain2 > ans {
ans = sum2 + maxGain2
}
return ans
}
// 计算最大子段和（如果全为负数则返回0）
func maxSubarraySum(arr []int) int {
maxEndingHere := 0
maxSoFar := 0
for _, v := range arr {
maxEndingHere += v
if maxEndingHere < 0 {
maxEndingHere = 0
}
if maxEndingHere > maxSoFar {
maxSoFar = maxEndingHere
}
}
return maxSoFar
}
// 返回数组的相反数
func neg(arr []int) []int {
res := make([]int, len(arr))
for i, v := range arr {
res[i] = -v
}
return res
}
