【leetcode】加减的目标值

0 、参考资料

分割等和子集 背包问题

一、代码思路

给定一个正整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

二、 代码思路

本题有两种思路来解决问题：

• 使用回溯算法
  每个元素都可以加 + 或者 加 -，所以每个数字有两种状态可以选择，一共有n个数字，也就是有 2^n 中选择的方法。对应到回溯搜索树上就是一颗完全的二叉搜索树。可以想象一下选择结果。
  所以，可以使用回溯把所有子集结果选出来，判断哪些子集和为target即可。
• 转换为背包问题使用动态规划
  我们假设sum为数组之和，neg为加上 - 号元素的之和，所以
  sum - neg - neg = target（neg是正的），所以问题就转换成
  neg = (sum - target) / 2 ,从数组中选出几个数之和为neg，这样的背包问题，与上一道题：分割等和子集 一摸一样。

详细解释请看Leetcode官方题解

三、代码题解

//这是Go中的回溯算法
//https://leetcode.cn/problems/YaVDxD/solutions/1025570/jia-jian-de-mu-biao-zhi-by-leetcode-solu-be5t/
func findTargetSumWays(nums []int, target int) int {
    //var arr [][]int
    //arr1 := new([2]int)
    //target为负的，无法初始化二维数组
    /*
    for x := 0; x < len(nums); x++ {  //循环为一维长度
	    ar := make([]int, target) //创建一个一维切片,分配一片内存空间，然后把指针给ar
	    arr = append(arr, ar) //把一维切片,当作一个整体传入二维切片中
    }
    fmt.Printf("The sum of the array is: %v", *&arr[0])
    fmt.Printf("The sum of the array1 is: %v", arr1)
    */
    //回溯
    var count int = 0
    dfs(0,target,len(nums),0,&nums,&count)
    return count
}
func dfs(cur int, target int, length int, sum int, nums *[]int, count *int) {
    if cur == length {
        if target == sum {
            *count++
        }
        return
    }
    //先考虑+
    sum += (*nums)[cur]
    dfs(cur + 1, target, length, sum, nums, count)
    sum -= (*nums)[cur]
    //再考虑-
    sum -= (*nums)[cur]
    dfs(cur + 1, target, length, sum, nums, count)
    sum += (*nums)[cur]
}

动态规划(这个有一点问题,没来得及调)：

func findTargetSumWays(nums []int, target int) int {
    //动态规划
    //sum - neg - neg = target
    //neg = (sum - target) / 2
    var sum int
    for _, num := range(nums) {
        sum += num
    }
    //相当于从nums数组中找出几个数之和等于neg，与上一道背包问题一摸一样
    if (sum - target) % 2 != 0 {
        return 0
    }
    var neg = (sum - target) / 2 

    var dp[][]int
    for i := 0; i < len(nums) + 1; i++ {
        ar := make([]int, neg + 1)
        dp = append(dp, ar)
    }
    //dp[0][0] = 1
    //dp[0][j] = 0
    //dp[i][j] 表示，从0 - i个数中选数之和等于j的方案
    dp[0][0] = 1
    for j := 1; j < neg + 1; j++ {
        dp[0][j] = 0
    } 
    //fmt.Println(len(dp))
    for i := 1; i < len(nums) + 1; i++ {
        //fmt.Println("i is %v",i)
        for j := 0; j < neg + 1; j++ {
            if j < nums[i - 1] {
                //表示nums[i]这个数不能选，所以从 0 - i 中选出和为j 的方案与 0 - j-1 一致
                dp[i][j] = dp[i - 1][j]
                //fmt.Println(dp[i][j])
            } else {
                //可以选该数也可以不选该数,这里是nums[i - 1]的原因就是，我们为了便于判断边界值数组长款都加了一个长度
                dp[i][j] = dp[i - 1][j]
                dp[i][j] += dp[i][j - nums[i - 1]]
                fmt.Println(dp[i][j])
                temp := dp[i - 1][j] 
                temp2 := dp[i][j - nums[i - 1]]
                temp3 := temp + temp2
                //dp[i][j] = temp3
                fmt.Println(temp)
                fmt.Println(temp2 == dp[i][j - nums[i - 1]])
                fmt.Println(temp3)
                fmt.Println(i)
                fmt.Println(j)
                fmt.Println(dp[i - 1][j])
                fmt.Println(dp[i][j - nums[i - 1]])
                fmt.Println(dp[i][j])
            }
        }
    }
    return dp[len(nums)][neg]
}

func dfs(cur int, target int, length int, sum int, nums *[]int, count *int) {
    if cur == length {
        if target == sum {
            *count++
        }
        return
    }
    //先考虑+
    sum += (*nums)[cur]
    dfs(cur + 1, target, length, sum, nums, count)
    sum -= (*nums)[cur]
    //再考虑-
    sum -= (*nums)[cur] 
    dfs(cur + 1, target, length, sum, nums, count)
    sum += (*nums)[cur]
}