【入门版动态规划（dp)】从斐波那契额数列入手，一步步解决跳台阶问题【由dfs(深度优先搜索)到记忆化搜索再到递推】

---

欢迎来到王火火的学习频道

你好！ 这里是学习零基础入门动态规划，运用斐波那契额数列来更进一步了解动态规划的敲门砖。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、斐波那契额数列是什么？

定义：这个数列从第3项开始，每一项都等于前两项之和。
递推公式:

1. F(0)=1,
2. F(1)=1;
3. F(n)=F(n-1)+F(n-2) (n>=2,n属于正整数）

二、跳台阶问题是什么？

一个楼梯共有n阶台阶，每次可以走一级或者两级，问从第0阶台阶走到第n阶一共有多少种方案？

三、解决动态规划的方法

3.1 解决动态规划问题一般分为以下三个步骤：

1. 穷举法，暴力搜索 dfs
2. 记忆化搜索/减枝
3. 自底向上，推出最后的问题。改写成递推形式。

3.2不理解步骤的可以先看下面解释：（方便理解下面的操作）

1.深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。

2.记忆化搜索=暴力dfs+记录答案

3.递推的公式=dfs向下递归的公式

4.递推数组的初始值=递归的边界

四：具体操作

步骤一：用dfs(深度优先算法）分析跳台阶问题

分析过程如下：

• 当n=1时，F（1）=1；

• 当n=2时，F（2）=2； 可以是连续走两个1，或者直接走一个2；

• 当n=3时，F（3）=3； F(3)=F(2)+F(1);
  
  ------------------------------------- 图1 当n=3时的情况---------------------------------------------------

• 当n=4时，F（4）=5； F(4)=F(3)+F(2);

• ------------------------------------------- 图2 当n=4时的情况---------------------------------------------------

• 当n=5时，F（5）=8； F(5)=F(4)+F(3);
  

分析得出
符合斐波那契额数列规律。可以运用斐波那契额数列算法解决。

import java.util.Scanner;

public class aaa {
    public static int climbStairs(int n) {
        if(n==1)  return 1;           
          else if(n==2)  return 2;
              else    return climbStairs(n-1)+climbStairs(n-2);

    }

    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("aaa");
        int n=scanner.nextInt();     //从键盘输入一个整数
        int num=climbStairs(n);
        System.out.println(num);
    }
}

``

缺点：时间复杂度为2的n次方 当n>42的时候 就会出现超出时间限制。

步骤二：记忆化搜索/减枝（用空间换时间）

公式： 记忆化搜索=暴力dfs+记录答案

代码如下：

import java.util.Scanner;

public class aaa {

	 static int[] memory=new int[50];    //创建一个空数组用来存储遍历过的n
	 //这个数组的大小一定要大于你输入n的值
	 
	
    public static int climbStairs(int n) {
    	if(memory[n]>0)  return memory[n];     //当memory[n]的值不为0时，说明已经遍历过，存储到数组中了。直接返回值就行。
    	int sum=0;     //创建一个int变量来计算当台阶数为n时，一共有多少种走法。
    	
        if(n==1)  sum= 1;           
          else if(n==2)  sum= 2;
              else    sum= climbStairs(n-1)+climbStairs(n-2);
        
        memory[n]=sum;
        return memory[n];

    }

    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("aaa");
        int n=scanner.nextInt();     //从键盘输入一个整数

        int num=climbStairs(n);
        System.out.println(num);
    }
}

优点：省去了很多分支，节省了很多时间。

步骤三：自底向上，推出最后的问题。改写成递推形式。

是否可以从边界出发，自底向来推。

import java.util.Scanner;

public class aaa {

	 static int[] memory=new int[50];    //创建一个空数组用来存储遍历过的n
	 //这个数组的大小一定要大于你输入n的值
	
   
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("aaa");
        int n=scanner.nextInt();     //从键盘输入一个整数
        
        memory[1]=1;
        memory[2]=2;
        for(int i=3;i<=n;i++) {
        	memory[i]=memory[i-1]+memory[i-2];      //这个递推公式就是dfs的向下递归公式；
        }

        System.out.println(memory[n]);
    }
}

当写完这个代码，再来读这写话，是否会有更深的理解：
1.深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。

2.记忆化搜索=暴力dfs+记录答案

3.递推的公式=dfs向下递归的公式

4.递推数组的初始值=递归的边界

步骤四：再优化，试着把空间再优化（把记录已经运算过的值的数组给去掉）

import java.util.Scanner;

public class aaa {

    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("aaa");
        int n=scanner.nextInt();     //从键盘输入一个整数
        int a=0;    
        int b=1;
        int c=2;
        for(int i=3;i<=n;i++) {
        	a=b+c;   //memory[i]
        	b=c;  //memory[i-1]
        	c=a;  //memory[i-2]
        }
        System.out.println(a);
    }
}

总结

我们在解决这个问题的时候，一步步的优化。从刚开始的暴力解法，发现当n大于一定数时，就会出现超时的现象。我们就通过记忆化搜索来优化时间。当完成记忆化搜索时，我们可以进一步将dfs改为递推，进一步省去了分解问题的过程，直接从边界开始往上推。最后我们又通过三个变量，代替了当初的记忆化数组，来优化空间。
在这里一定要理解和牢记3.2里的内容。这将会是我们优化代码的核心思想。