动态编程-带记忆的树递归

如何解决动态编程-带记忆的树递归

针对该问题：

以M×N网格考虑昆虫。昆虫开始于左下角（0，0），并希望结束于右上角（M-1，N-1）。昆虫只能向右或向上移动。编写一个函数路径，该路径采用网格的长度和宽度，并返回昆虫从头到目标可以采用的不同路径数。

例如，“ 2 x 2”网格共有两种方式使昆虫从起点移动到目标。对于3 x 3的网格，昆虫有6条不同的路径（上面仅显示3条）。

---

以下是递归解决方案：

package main

import "fmt"

func paths(m,n int) int {

    var traverse func(int,int) int
    traverse = func(x,y int) int {

        if x >= m || y >= n {
            return 0
        }
        if x == m-1 && y == n-1 {
            return 1
        }
        return traverse(x+1,y) + traverse(x,y+1)
    }
    return traverse(0,0)
}

func main() {
    fmt.Println(paths(1,157))
}

---

随着N的增加，效果如下：

fmt.Println(paths(1,1)) // 1
fmt.Println(paths(2,2)) // 2
fmt.Println(paths(3,3)) // 6
fmt.Println(paths(4,4)) // 20
fmt.Println(paths(5,5)) // 70
fmt.Println(paths(6,6)) // 252
fmt.Println(paths(7,7)) // 924

---

记忆化可以应用于斐波那契问题，使用树递归来重用以前的计算

记住这个路径问题有意义吗？重用以前的计算

（注意：此问题旨在应用树递归的概念，如here所述。）

解决方法

该问题是众所周知的，并且具有（M + N-2选择M-1）或等效的解决方案（M + N-2选择N-1）。使用需要O（NM）时间的记忆是否有意义？并非如此，因为可以用相对简单的代码在O（min（M，N））时间（算术运算）中计算二项式系数。

例如（playground link）：

package main

import (
    "fmt"
    "math/big"
)

func paths(n,m int) *big.Int {
    return big.NewInt(0).Binomial(int64(n+m-2),int64(m-1))
}

func main() {
    for i := 1; i < 10; i++ {
        fmt.Println(i,paths(i,i))
    }
}

,

是的，可以使用备忘录。要进行的关键观察是在3x3网格中考虑一个网格（1，1）：

（2，0）（2，1）（2，2）

（1，0）（1、1）（1、2）

（0，0）（0，1）（0，2）

网格（1，1）中的路径数等于（1，0）的路径数加上（0，1）的路径数，因为只有两种可能的方式可以到达路径（1，1）。

概括：

npath（x，y）= npath（x-1，y）+ npath（x，y-1）

其中npath（x，y）=访问网格（x，y）的可能路径的数量

因此，如果您向后构建递归，则可以应用备注。倒退是指您必须从较小的情况开始，其中npath（_，0）= 1且npath（0，_）=1。下划线表示任何值。

简单运行此算法会在3x3的网格中产生以下数量的路径：

1 3 6

1 2 3

1 1 1

实际上，您可以执行双嵌套循环，而不必进行递归优化。