数据结构 5. 递归

一、递归

1. 递归的定义

递归就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方法。
递归常与分治思想同时使用，能产生许多高效的算法。递归常用来解决结构相似的问题。所谓结构相似，是指构成原问题的子问题与原问题在结构上相似，可以用类似的方法解决。具体地，整个问题的解决，可以分为两部分：第一部分是一些特殊情况，有直接的解法；第二部分与原问题相似，但比原问题的规模小，并且依赖第一部分的结果。
实际上，递归是把一个不能或不好解决的大问题转化成一个或几个小问题，再把这些小问题进一步分解成更小的小问题，直至每个小问题都可以直接解决。因此，递归有两个基本要素：
（1） 边界条件：确定递归到何时终止，也称为递归出口。
（2） 递归模式：大问题是如何分解为小问题的，也称为递归体。
递归函数只有具备了这两个要素，才能在有限次计算后得出结果。

2. 递归的实现

2.1 斐波那契数列求值

def fib(n):
    if n==0 or n==1:
        return n
    return fib(n-1)+fib(n-2)

2.2 编程实现求阶乘 n!

def Factorial(n):
    if n<=1:
        return 1
    return n*Factorial(n-1)
Factorial(5)

2.3 编程实现一组数据集合的全排列

# 可用包 【自带的库itertools.permutations】获取子集的全排列
COUNT=0
def perm(n,begin,end):
    global COUNT
    if begin>=end:
        print (n)
        COUNT +=1
    else:
        i=begin
        for num in range(begin,end):
            n[num],n[i]=n[i],n[num]
            perm(n,begin+1,end)
            n[num],n[i]=n[i],n[num]
n=[1,2,3,4]
perm(n,0,len(n))
print (COUNT)

3. 练习

70. Climbing Stairs（爬楼梯）

[https://leetcode-cn.com/problems/climbing-stairs/]
题目描述
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶
   示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

解题思路
设dp[i]表示到达点第i层时有多少种方法，而到达第i层可以由i-1层跳一层上去，也可以由i-2层跳两层上去，那么状态转移矩阵可以写为：

代码实现

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0]*n
        if n == 1:
            return 1
        dp[0] = 1
        dp[1] = 2
        for i in range(2,n,1):
            dp[i] = dp[i-1]+dp[i-2]
        return dp[-1]

746. 使用最小花费爬楼梯

[https://leetcode-cn.com/problems/min-cost-climbing-stairs/]
题目描述
数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 costi。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。
示例 2:

输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释: 最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。
注意：

cost 的长度将会在 [2, 1000]。
每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。

代码实现

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)
        dp = [0]*n
        dp[0] = cost[0]
        dp[1] = cost[1]
        for i in range(1,n):
            dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
        return min(dp[-1],dp[-2])