【Java】动态规划---青蛙跳台阶问题

什么是动态规划?  

动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一个子问题的解推出。
动态规划和分治法相似，都是通过分解，求解，并组合子问题来求解原问题。分治法将问题划分成相互独立互不相交的子问题，递归求解子问题，再将它们的解组合起来，求出原问题的解。与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。在这种情况下，分治算法会做出许多不必要的工作，它会反复的求解那些公共子子问题。而动态规划算法对每个子子问题只求解一次，将结果保存到表格（数组）中，从而无需每次求解一个子子问题都要重新计算。

需求：

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

分析：

此题的突破口在台阶数；台阶数不一样，结果就不一样；由台阶数来找规律。

通过分析台阶数，可以看出当台阶数为n时，跳法数为前两个之和，设跳法数为函数f(n),则有：

f  (n) = f（n-1）+  f（n-2）；

这是一个一个斐波那切数列，所以转化为求解斐波那切数列问题

代码实现：

方法一：递归思想

import java.util.Scanner;
public class Test {
	  public static int f(int n) {
		  if(n!=1) {
			  if(n!=2) {
				  return f(n-1)+f(n-2);
			  }else return 2;
		  }else return 1 ;
	  }
	  public static void main(String[] args) {
		  System.out.println("请输入台阶数：");
		  Scanner s = new Scanner(System.in);
		  int n = s.nextInt();
		  System.out.println("跳法总数："+"\n"+f(n));
	}
}

分析：

1. 首先，当位数为1时返回值为1；位数为2时返回2；因为他们是起始值；
2. 然后，当位数为3时，其返回值 = 2 = 1 + 1；当位数为3时，其返回值 = 2 = 1 + 1；

                    当位数为4时，其返回值 = 3 = 2 + 1；

                    当位数为3时，其返回值 = 5 = 3 + 2；

                    当位数为3时，其返回值 = 8 = 5 + 3；

                    ......

所以由以上可得，大于等于3的情况下，当前位数的值

f  (n) = f（n-1）+  f（n-2）。

输出示例为

请输入台阶数：
8
跳法总数：
34
 

方法二：备忘录法（也叫自顶向下法）（还是利用了递归的思想）

/**
		 * 自顶向下 (递归) 动态规划（备忘录）
		 * @param n
		 * @return
		 */
		public static int f(int n,int[] bak) {
			if(n == 0||n == 1) {
				return 1;
			}
			
			if(bak[n] != -1) {
				return bak[n];
			}
			
			int result = f(n - 1,bak) + f(n - 2,bak);
			bak[n] = result;
			return result;
		}

此方法依然是按照自然的递归形式编写过程，但过程中会保存每个子问题的解（通常保存在一个数组中）。当需要计算一个子问题的解时，过程首先检查是否已经保存过此解。如果是，则直接返回保存的值，从而节省了计算时间；如果没有保存过此解，按照正常方式计算这个子问题。我们称这个递归过程是带备忘的。

方法三：自底向上法

		public static int fib(int n)
		{
		        if(n<=2)
		            return n;
		        int []Memo=new int[n+1];
		        Memo[1]=1;
		        Memo[2]=2;
		        for(int i=3;i<=n;i++)
		        {
		            Memo[i]=Memo[i-1]+Memo[i-2];
		        }       
		        return Memo[n];
		}

首先恰当的定义子问题的规模，使得任何问题的求解都只依赖于更小的子问题的解。因而我们将子问题按照规模排序，按从小到大的顺序求解。当求解某个问题的时候，它所依赖的更小的子问题都已经求解完毕，结果已经保存到了数组中。