标题:1477找两个和为目标且不重叠的子数组-中等
题目
给你一个整数数组 arr 和一个整数值 target 。
请你在 arr 中找 两个互不重叠的子数组 且它们的和都等于 target 。可能会有多种方案,请你返回满足要求的两个子数组长度和的 最小值 。
请返回满足要求的最小长度和,如果无法找到这样的两个子数组,请返回 -1 。
示例1
输入:arr = [3,2,2,4,3], target = 3
输出:2
解释:只有两个子数组和为 3 ([3] 和 [3])。它们的长度和为 2 。
示例2
输入:arr = [7,3,4,7], target = 7
输出:2
解释:尽管我们有 3 个互不重叠的子数组和为 7 ([7], [3,4] 和 [7]),但我们会选择第一个和第三个子数组,因为它们的长度和 2 是最小值。
示例3
输入:arr = [4,3,2,6,2,3,4], target = 6
输出:-1
解释:我们只有一个和为 6 的子数组。
示例4
输入:arr = [5,5,4,4,5], target = 3
输出:-1
解释:我们无法找到和为 3 的子数组。
示例5
输入:arr = [3,1,1,1,5,1,2,1], target = 3
输出:3
解释:注意子数组 [1,2] 和 [2,1] 不能成为一个方案因为它们重叠了。
提示
1 <= arr.length <= 10^5
1 <= arr[i] <= 1000
1 <= target <= 10^8
代码Go
package main
import "fmt"
func main() {
arr := []int{7, 3, 4, 7}
target := 7
ans := minSumOfLengths(arr, target)
fmt.Printf("ans: %v\n", ans)
}
func minSumOfLengths(arr []int, target int) int {
sum := 0
var temp []int = make([]int, 0)
for i := 0; i < len(arr); i++ {
sum += arr[i]
temp = append(temp, arr[i])
for sum >= target {
if sum == target {
ansList = append(ansList, temp)
sum = 0
temp = make([]int, 0)
break
}
sum -= temp[0]
temp = temp[1:]
}
}
return findAns(ansList)
}
// ----------------------------------------------------
// 一开始题意理解错误,认为应该用回溯算法,找所有子集
// 没想到题意是必须相邻的运算,记为子数组
// 以下是回溯算法的题型扩展
var ansList [][]int = make([][]int, 0)
func minSumOfLengths1(arr []int, target int) int {
// 1. 找到所有的和为target的数组 ansList
var temp []int = make([]int, 0)
findAll(arr, target, temp, 0)
fmt.Printf("ansList: %v\n", ansList)
// 2. 在ansList中找两个长度最小的
return findAns(ansList)
}
func findAll(arr []int, target int, temp []int, lever int) {
if target == 0 {
ansList = append(ansList, temp)
return
}
if target < 0 {
return
}
for i := lever; i < len(arr); i++ {
temptarget := target
if temptarget < 0 {
continue
}
// 回溯算法
temptarget -= arr[i]
tempx := append(temp, arr[i])
findAll(arr, temptarget, tempx, i+1)
temptarget += arr[i]
tempx = tempx[:len(tempx)-1]
}
}
func findAns(ansList [][]int) int {
if len(ansList) < 2 {
return -1
}
minVal := 100000
preVal := 100000
for _, v := range ansList {
if minVal > len(v) {
preVal = minVal
minVal = len(v)
continue
}
if len(v) >= minVal && len(v) < preVal {
preVal = len(v)
}
}
return preVal + minVal
}