递归思想及动态规划思想学习笔记

最新推荐文章于 2024-11-21 10:33:20 发布

melody_44154393

最新推荐文章于 2024-11-21 10:33:20 发布

阅读量3.2k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_44154393/article/details/85180430

本文介绍了递归和动态规划的概念及其在编程中的应用。递归包括定义、Python实现及防止栈溢出的尾递归优化。动态规划则涉及概念、应用场景，如最长公共子序列和子串的求解策略，通过案例分析展示了动态规划解决问题的思路。

一、递归

1、概念

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

注：
– 递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
– 使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
– 解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
（尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。）

2、python实现

#直接调用自己：
def func():
    print('from func')
    func()
    
func()

#间接调用自己
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
    foo()

foo()

#递归的实现：
def age(n):
    if n == 1:
        return 18
    return age(n-1)+2

print(age(5))

# age(5)=age(4)+2 第一次进入
# age(4)=age(3)+2 第二次进入
# age(3)=age(2)+2 第三次进入
# age(2)=age(1)+2 第四次进入
# age(1)=18 第五次进入，最后判断终止条件

# age(n)=age(n-1)+2 #n>1  递归终止条件
# age(1)=18 #n=1          等于终止条件

3、小结

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

二、动态规划

1、概念

求解决策过程(decision process)最优化的数学方法。

2、应用领域

最长公共子序列，最长公共子串，最长递增子序列，最长回文子串，硬币的组合数，硬币的最少组合方法，最小编辑距离，背包问题

3、案例分析

（1）求最长公共子序列（不一定连续）

问题描述
给定两个序列，找出在两个序列中同时出现的最长子序列的长度。一个子序列是出现在相对顺序的序列，但不一定是连续的。
分析
– 假设str1的长度为M，str2的长度为N,生成的大小为M*N的矩阵dp。dp[i][j]的含义是str[0…i]与str2[0…j]的最长公共子序列的长度。
– 矩阵dp第一列，即dp[i][0]，代表str1[0…i]与str2[0]的最长公共子序列长度。str2[0]只有一个字符，所以dp[i][0]最大为1，如果str[i] == str2[0]，则令dp[i][0]为1，一旦dp[i][0]被设为1，则令dp[i+1…M][0]全部为1
– 矩阵dp第一行，即dp[0][j]，与步骤1同理。如果str1[0]==str[j],则令dp[0][j]为1，一旦dp[0][j]被设为1，则令dp[0][j+1…N]全部为1
– 其他位置，dp[i][j]的值只可能来自一下三种情况，三种可能的值中，选择最大的值即可：
(a)情况一：可能是dp[i-1][j]的值，这代表str1[0…i-1]与str2[0…j]的最长公共子序列长度。举例：str1 = “A1BC2”, str2 = “AB34C” str1[0…3]为"A1BC",str2[0…4]为"AB34C",这两部分最长公共子序列为"ABC",即dp[3][4]为3. str1整体和str2整体最长公共子序列也是"ABC"，所以dp[4][4]可能来自dp[3][4]
(b)情况二：同理可知，dp[i][j]的值也可能是dp[i][j-1]
©情况三：如果str1[i]==str2[j],还可能是dp[i-1][j-1]+1的值。举例：比如str1 =“ABCD”, str2 = “ABCD”. str1[0…2]即“ABC”与str2[0…2]即“ABC”的最长公共子序列为"ABC",也就是dp[2][2]为3。因为str1和str2的最后一个字符都是"D",所以dp[i][j] = dp[i-1][j-1]+1
代码如下

def findLongest(self, A, n, B, m):  
    #新建一个m行n列的矩阵  
    matrix = [0] * m * n  
    #1、矩阵的第一行，即matrix[0][i]，代表str1[0]与str2[0...n]的最长公共子串.  
    # str2[0]只有一个字符，所以matrix[i][0]最大为1  
    for i in range(n):  
        if A[i] == B[0]:  
            for j in range(i,n):  
                matrix[j] = 1  
    #2、矩阵的第一列，matrix[i][0]最大为1  
    for i in range(m):  
        if B[i] == A[0]:  
            for j in range(i,m):  
                matrix[j*n] = 1  
    #3、其他位置,matrix[i][j]有三种情况，matrix[m][n]即为所求的最长公共子序列长度  
    for i in range(1,m):  
        for j in range(1,n):  
            if B[i] == A[j]:  
                matrix[i*n+j] = max(matrix[(i-1)*n+j-1]+1,matrix[(i-1)*n+j],matrix[i*n+j-1])  
            else:  
                matrix[i*n+j] = max(matrix[(i-1)*n+j],matrix[i*n+j-1])  
    return matrix[m*n-1]

（2）求最长公共子串（连续）

问题
给定两个序列，找出在两个序列中同时出现的最长子序列的长度。子串的意思是要求为连续的子序列。
分析
矩阵的第一行，即matrix[0][i]，代表str1[0]与str2[0…n]的最长公共子串.
代码如下

def findLongest(self, A, n, B, m):  
    #新建一个m行n列的矩阵  
    matrix = [0] * m * n  
    #1、矩阵的第一行，即matrix[0][i]，代表str1[0]与str2[0...n]的最长公共子串.  
    # str2[0]只有一个字符，所以matrix[i][0]最大为1  
    for i in range(n):  
        if A[i] == B[0]:  
            matrix[i] = 1  
    #2、矩阵的第一列，matrix[i][0]最大为1  
    for i in range(m):  
        if B[i] == A[0]:  
            matrix[i*n] = 1  
    #3、其他位置  
    max = 0  
    for i in range(1,m):  
        for j in range(1,n):  
            if B[i] == A[j]:  
                matrix[i*n+j] = matrix[(i-1)*n+j-1]+1  
                if max<matrix[i*n+j]:  
                    max = matrix[i*n+j]  
    return max