LeetCode-1477找两个和为目标且不重叠的子数组-中等

标题：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
}