标签：返回 tiny 初始 解答 end 斐波那契数列 bre turn class
我现在是初学的状态，在此来记录我的刷题过程，便于以后复习巩固。
我leetcode从动态规划开始刷，语言用的java。
我上网查了一下动态规划，了解到动态规划是“带有备忘录的递归”，
而大多数用来理解动态规划的例子都是斐波那契数列,就是那个经典的递归式
f(i)=f(i-1)+f(i-2) ,f(1)=f(2)=1
f(5)=f(4)+f(3);
f(4)=f(3)+f(2);
f(3)=f(2)+f(1);
然后我们就发现了重复的部分，在求f(5)和f(4)的时候都要求f(3),那么它们都要做一次f(3)的递归操作，来得到f(3)的值。
我想这是很不值得的，没必要同样的操作执行两遍。并且我们知道当f(n)的n比较大时，是很多重复的部分的，这也就意味着有很大的优化空间。
因此有了所谓的“备忘录”，也就是用一个数组来记录每个状态的结果，比如f(5)就是n为5时f(n)的状态。
这样的话，我们就可以在求f(n)的时候，先查看一下数组中是否记录了这一个状态的值，如果有，就直接从数组中拿，如果没有，就递归计算一下，再把这个值放到数组中去。这也是所谓的“以空间换时间”的思想。
int[] dp=new int[n+1];//dp[i]表示f(i)的值
在求f(x)时：
if(dp[x]==0)//未被记录到数组
dp[x]=f(x-1)+f(x-2)
return dp[x];
同时，递归也是会花费很多时间的，我们能否换一种方式呢？
这时候我们发现f(n)的状态之间存在递推关系，也就是f(n)=f(n-1)+f(n-2)
那么这就对应了动态规划的第二个关键因素状态转移方程，我们把递推关系转化成数组dp前后的关系，
比如斐波拉契数列的就是dp[i]=dp[i-1]+dp[i-2]
有了这个方程，我们就可以循环求dp[i]的值了
dp[5]=dp[4]+dp[3],
dp[4]=dp[3]+dp[2],
dp[3]=dp[2]+dp[1];
那么在求dp[5]的时候dp[4]和dp[3]已经是保存在数组了，便可以直接获得。
我们知道递推和递归一样，需要出口，也就是递归或递推到底的标志
在这道题中出口就是dp[1]=dp[2]=1;
有了这两个值，在循环的时候我们就可以求出所有的值了，这就是出口的意义。
感觉可以类比数学里数学归纳法。
//需要先做个判断
if(n==1||n==2)
return 1;
dp[1]=dp[2]=1;
for(int i=3;i<n+1;i++)
{
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
最后，我觉得重要的就是把握整体的边界情况，比如这里的n==1和n==2是不用递推关系的，而且dp[1]=dp[2]=1之前需要确定n>2才能赋值的，有的题目里还有给出参数为一个数组，这时需要考虑数组长度为0的情况等等
最后总结一下动态规划的四个要素（自己总结的）：
1.定义数组
2.找出递推关系
3.找出出口
4.把握整体边界
它们在程序中的位置是4->1->3->2
最后返回值
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1 阶 + 1 阶
2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶
1.设置数组：
通过题目，我们知道我们最终要求的是到达n阶有多少种方法，那不妨就设这个为dp[n]
那我们要求的数组dp[i]表示的就是到达i阶时有dp[i]种方法
2.找出递推关系:
那我们就要了解dp[i]是怎么来的了？
根据题目，我们知道，每次是可以跨一阶或者两阶的，那么dp[i]就只有两种方法得到
一种是由dp[i-2]跨两阶来的，还有一种是dp[i-1]跨一阶来的。
那么dp[i]的方法数应该等于dp[i-1]的加上dp[i-2]了。
因此，我们找出了递推关系dp[i]=dp[i-1]+dp[i-2]
3.找出出口：
根据递推式我们知道i>=2才能使用递推得到，不然下标就要<0了
那我们求一下出口dp[0]=0,0阶的时候肯定只有0种方法
dp[1]=1;1阶的时候只有跨1阶这一种方法。
但是这里还有一个dp[2]也是出口，可能被忽略掉,因为按照递推式dp[2]=dp[1]+dp[0]=1,而实际上dp[2]=2
4.把握整体边界：
n<=0,n==1,和n==2可以提前算出
代码
class Solution {
public int climbStairs(int n) {
//1.考虑整体边界
if(n<=0)
return 0;
if(n==1||n==2)
return n;
//2.设置数组
int []dp=new int[n+1];//dp[i]表示到达i阶，有dp[i]种方法
//3.考虑数组边界值
dp[0]=0;
dp[1]=1;
dp[2]=2;//注意2也是边界
//4.找出dp[i]与dp[i-1]的关系，循环获取所要获得的项dp[n];
//dp[i]=dp[i-1]+dp[i-2]
//要到达n阶可以有两种方法：一种是从i-1爬1阶来的，还有一种是i-2爬2阶来的
//因此需要求这两种方法之和
for(int i=3;i<=n;i++)
{
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
}
}
数组的每个索引做为一个阶梯，第 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]
1.设置数组：
通过题目，我们知道我们最终要求的是到达n阶的最低花费，那不妨就设这个为dp[n]
那我们要求的数组dp[i]表示的就是到达i阶时的最低花费,根据示例，我们可知最后要返回的结果应该是dp[len]
2.找出递推关系:
首先我们分析题目可知，消耗的体力值应该等于原来的加上到达的那一阶的体力值，因此如果跨两阶的话，应该是直接加上两阶中的后一阶的体力值的。
因为一次只能跨一阶或者两阶，因此dp[i]应该是dp[i-2]和dp[i-1]中比较小的那个加上i对应的体力值，即cost[i];
因此dp[i]=Math.min(dp[i-2],dp[i-1])+cost[i]
3.找出出口：
根据递推式下标我们知道i>1才能使用递推式
那么就需要求出dp[0]和dp[1]
dp[0]=cost[0];//到达0阶时的花费，只有一个
dp[1]=cost[1];//到达1阶一种是一阶一阶上,即cost[0]+cost[1],还有一种是直接上两阶cost[1],cost[1]更小
4.把握整体边界：
参数是一个cost数组，我们需要考虑数组长度为0的情况，递推式不覆盖下标为0和1的，因此也应该拿出来作为出口
if(len==0)
return 0;
if(len==1)
return cost[0];
if(len==2)
return cost[1];
class Solution {
public int minCostClimbingStairs(int[] cost) {
//设置出口
int len=cost.length;
if(len==0)
return 0;
if(len==1)
return cost[0];
if(len==2)
return cost[1];
//设置数组
int []dp=new int[len];//dp[i]表示到达第i阶时所花费的最小体力值
``
//设置数组边界
dp[0]=cost[0];
dp[1]=cost[1];
//找出数组的递推关系
int i;
for(i=2;i<len;i++)
{
dp[i]=Math.min(dp[i-2],dp[i-1])+cost[i];
}
//返回值
}
}
标签：返回 tiny 初始 解答 end 斐波那契数列 bre turn class
原文地址：https://www.cnblogs.com/zhang-qi123/p/12230376.html
