如何在golang中生成静态局部变量 主程序包 输入“fmt” func canSum（targetSum int，number…int）bool{ 如果targetSum==0{ 返回真值 } 如果targetSum

所以我在使用golang编程时遇到了一个问题，如果我在函数外声明我的记忆映射，那么所有函数调用都共享同一个映射，这会导致结果出错。

---

如果我在函数中声明映射，那么每次递归调用都会重新初始化映射。有没有办法使映射成为静态局部变量？

使用

映射参数编写不同的函数，并在其中执行递归操作。首先在
memo\u canSum
函数中调用该函数，并声明新映射

package main

import "fmt"

func canSum(targetSum int, numbers ...int) bool {
    if targetSum == 0 {
        return true
    }
    if targetSum < 0 {
        return false
    }
    for index := 0; index < len(numbers); index++ {
        if canSum(targetSum-numbers[index], numbers...) == true {
            return true
        }
    }
    return false
}

//var memo = map[int]bool{} //Getting wrong values due to shared function scope from package scope
func memo_canSum(targetSum int, numbers ...int) bool {
    memo := map[int]bool{} //Defeats dp func since we continue to reinitialize during recursive calls
    if _, exists := memo[targetSum]; exists {
        return memo[targetSum]
    }

    if targetSum == 0 {
        return true
    }
    if targetSum < 0 {
        return false
    }
    for index := 0; index < len(numbers); index++ {
        if memo_canSum(targetSum-numbers[index], numbers...) == true {
            memo[targetSum] = true
            return memo[targetSum]
        }
    }
    memo[targetSum] = false
    return false
}

func main() {

    //Non-Dp Solution
    fmt.Println(canSum(21, 2, 4, 8))
    fmt.Println(canSum(80, 2, 4, 8))
    fmt.Println(canSum(300, 7, 14))

    //Dp Solution
    fmt.Println(memo_canSum(21, 2, 4, 8))
    fmt.Println(memo_canSum(80, 2, 4, 8))
    fmt.Println(memo_canSum(300, 7, 14))
}

//var memo=map[int]bool{}//由于包作用域中的共享函数作用域而获取错误值
func memo_canSum（targetSum int，number…int）bool{
备注：=map[int]bool{}//失败dp func，因为我们在递归调用期间继续重新初始化
返回momoWithMap（备忘录、目标总数、数字…）
}
func momoWithMap（备忘录映射[int]bool、targetSum int、数字…int）bool{
如果存在：=备忘录[targetSum]；存在{
返回备忘录[目标金额]
}
如果targetSum==0{
返回真值
}
如果targetSum<0{
返回错误
}
对于索引：=0；索引当你做递归调用时，把它作为参数传递。是的，我害怕，猜我必须重写C++中的问题，因为我必须要符合问题描述。我不明白为什么…在您的情况下，您可以使用包映射，并在
memo\u canSum
的开头对其进行初始化。一个更具弹性的解决方案是让
memo\u canSum
调用一个函数，该函数将map作为参数，执行实际的工作和递归，从而保持
memo\u canSum
的签名完整。
package main

import "fmt"

func canSum(targetSum int, numbers ...int) bool {
    if targetSum == 0 {
        return true
    }
    if targetSum < 0 {
        return false
    }
    for index := 0; index < len(numbers); index++ {
        if canSum(targetSum-numbers[index], numbers...) == true {
            return true
        }
    }
    return false
}

//var memo = map[int]bool{} //Getting wrong values due to shared function scope from package scope
func memo_canSum(targetSum int, numbers ...int) bool {
    memo := map[int]bool{} //Defeats dp func since we continue to reinitialize during recursive calls
    if _, exists := memo[targetSum]; exists {
        return memo[targetSum]
    }

    if targetSum == 0 {
        return true
    }
    if targetSum < 0 {
        return false
    }
    for index := 0; index < len(numbers); index++ {
        if memo_canSum(targetSum-numbers[index], numbers...) == true {
            memo[targetSum] = true
            return memo[targetSum]
        }
    }
    memo[targetSum] = false
    return false
}

func main() {

    //Non-Dp Solution
    fmt.Println(canSum(21, 2, 4, 8))
    fmt.Println(canSum(80, 2, 4, 8))
    fmt.Println(canSum(300, 7, 14))

    //Dp Solution
    fmt.Println(memo_canSum(21, 2, 4, 8))
    fmt.Println(memo_canSum(80, 2, 4, 8))
    fmt.Println(memo_canSum(300, 7, 14))
}

//var memo = map[int]bool{} //Getting wrong values due to shared function scope from package scope
func memo_canSum(targetSum int, numbers ... int) bool {
    memo := map[int]bool{} //Defeats dp func since we continue to reinitialize during recursive calls
    return momoWithMap(memo, targetSum, numbers...)
}

func momoWithMap(memo map[int]bool, targetSum int, numbers ... int) bool{
    if _, exists:=memo[targetSum]; exists{
        return memo[targetSum]
    }

    if targetSum == 0 {
        return true
    }
    if targetSum < 0{
        return false
    }
    for index:= 0; index < len(numbers); index++{
        if momoWithMap(memo, targetSum - numbers[index], numbers...) == true {
            memo[targetSum] = true
            return true
        }
    }
    memo[targetSum] = false
    return false
}