梯有N阶，上楼可以一步上一阶，也可以一次上二阶（Java实现）

走楼梯问题
组合数学和动态规划算法

欢迎查看相关动态规划问题：动态规划之：让你轻松理解背包算法

本文尝试对“走楼梯”问题做一个较为系统的解释。

代码可以自己复制出去，调试运行和理解！

牛客提交的版本

【1.递归实现】

2.更高效的数据迭代实现

例3：一共有10级,每次可走一步也可以走两步.必须要8步走完10级楼梯. 问:一共有多少种走法?
分析：走一步的需要6次，走两步的需要2次。因此，本题是6个1、2个2的组合问题。在6个一步中，插入2个两步的,因可放在第一个1步之前,也可以放在最后一个1步之后,所以6个1步有7个空.因此,如果两个两步在一起有c(7,1)种;如果两个两步的分开来插有C(7，2）种，因此共有
c(7,1)+c(7,2)=7+21=28(种)=C(8,2)=C（8,6）
总数=8步中选2中走两步的=8步中选6个走一步的

Java编程实现：（数组迭代，动态规划，递归）

package com.test;
public classzoutaijie {
// 梯有N阶，上楼可以一步上一阶，也可以一次上二阶。编一个程序，计算共有多少种不同的走法。如果上20阶会有几种走法
public staticlongresult[]=new long[100];
public staticvoidmain(String[] args) {
result[0]=result[1]=1;
for(inti=2;i<=result.length;i++)
result[i]=-1;
//s不能太大，否则int溢出
int s =60;
//动态规划
long startTime = System.currentTimeMillis();
System.out.println("动态规划解决："+fun1(s));
long endTime = System.currentTimeMillis();
System.out.println("动态规划解决-程序运行时间："+(endTime-startTime)+"ms");//数组叠加
long startTime2 = System.currentTimeMillis();
System.out.println("数组叠加实现："+fun2(s));
long endTime2 = System.currentTimeMillis();
System.out.println("数组叠加实现-程序运行时间："+(endTime2-startTime2)+"ms");//递归方法
long startTime1 = System.currentTimeMillis();
System.out.println("递归方法解决："+fun(s));
long endTime1 = System.currentTimeMillis();
System.out.println("递归方法解决-程序运行时间："+(endTime1-startTime1)+"ms");
}public staticlongfun(ints){
if(s==0 || s==1)
return 1;
else{
return fun(s-1)+fun(s-2);
}}public staticlongfun1(ints){
if(result[s]>=0) {
return result[s];
}else{
result[s]=(fun1(s-1)+fun1(s-2));
return result[s];
}
}public staticlongfun2(ints){
long result_1[]=newlong[s+1];//注意这个要大一个，多了个第0个
result_1[0]=result_1[1]=1;
for(inti=2;i<=s;i++)
result_1[i]=result_1[i-1]+result_1[i-2];
return result_1[s];//s就是第s+1个
}}

分析：
s=48和s=60输出结果，显然数组叠加和动态规划效率高很多很多，不是一个数量级的！

变形：如果每次可以走一步，2步，3步。。。。N步，那一共有多少种？

1）这里的f(n) 代表的是n个台阶有一次1,2,...n阶的跳法数。

2）n = 1时，只有1种跳法，f(1) = 1

3) n = 2时，会有两个跳得方式，一次1阶或者2阶，这回归到了问题（1），f(2) = f(2-1) + f(2-2)

4) n = 3时，会有三种跳得方式，1阶、2阶、3阶，

那么就是第一次跳出1阶后面剩下：f(3-1);第一次跳出2阶，剩下f(3-2)；第一次3阶，那么剩下f(3-3)

因此结论是f(3) = f(3-1)+f(3-2)+f(3-3)

5) n = n时，会有n中跳的方式，1阶、2阶...n阶，得出结论：

f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)

6) 由以上已经是一种结论，但是为了简单，我们可以继续简化：

f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)

f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)

可以得出：

f(n) = 2*f(n-1)

7) 得出最终结论,在n阶台阶，一次有1、2、...n阶的跳的方式时，总得跳法为：

| 1 ,(n=0 )

f(n) = | 1 ,(n=1 )

| 2*f(n-1),(n>=2)

也可以这样更简单：

每个台阶都有跳与不跳两种情况（除了最后一个台阶），最后一个台阶必须跳。所以共用2^(n-1)中情况

######################################################################################

猛然的一次实现：

package com.mytest.mymain;import java.io.*;public class Main{
public static void main(String[] args) throws Exception{//方式1   #############
java.util.Scanner sc=new java.util.Scanner(System.in);//001
String str;
while((str=sc.nextLine())!=null){  //002
int n=Integer.parseInt(str);
long[] result=new long[n+2];
result[1]=1;result[2]=2;if(n==1 || n==2 ){System.out.println(result[n]);}else{
for(int i=3;i<=n;i++){
result[i]=result[i-1]+result[i-2];
}
System.out.println(result[n]);}
}//方式2           #################/* BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String str;
while((str=br.readLine())!=null){
int n=Integer.parseInt(str);
long[] result=new long[n+2];
result[1]=1;result[2]=2;if(n==1 || n==2 ){System.out.println(result[n]);}else{
for(int i=3;i<=n;i++){
result[i]=result[i-1]+result[i-2];
}
System.out.println(result[n]);}
}*/}
}

线下两个方式都可以通过的，但是在线上牛客网调试方式2可以，方式1就不通过，方式一和方式二仅仅只是在001和002处两处差异，其他代码完全一样。

最终找到解决办法：

把002改为：

//while(sc.hasNext()){ //003
//str=sc.nextLine();

所以在寻求统一形式编码习惯的同时需要注意一些更多的细节区别。

欢迎读者思考，评论，发表自己观点！

##################################################

经典同原理题目，斐波那数列问题实现：

递归：f(n)=f(n-1)+f(n-2)，n=0,f=0;n=1,f=1;

非递归高效实现：

1.时间复杂度为O(n)

public class Solution {public int Fibonacci(int n) {int f_1=1;int f_2=0;int result=0;if(n<=0){  return 0;   }if(n==1){   return 1;   }if(n>=2){for(int i=2;i<=n;i++){result=f_1+f_2;f_2=f_1;f_1=result; }}return result;}
}

2.时间复杂度为O(logN)

利用如下数学公式：（一般要求非递归的动态规划实现，如上实现即可，这种不够实用，可做知识面储备）

梯有N阶，上楼可以一步上一阶，也可以一次上二阶（Java实现）相关推荐

Python 爬楼梯问题--有n阶台阶，上楼可以一步上1阶,2阶，3阶，计算共有多少种不同的走法？
Python爬楼梯问题:有n阶台阶,上楼可以一步上1阶,2阶,3阶,计算共有多少种不同的走法? 总共n步台阶(先假设n>3),f(n)表示n步台阶的走法总数 1.第一步如果是只走1步台阶,剩下的 ...
python爬楼梯多少种_Python 爬楼梯问题--有n阶台阶，上楼可以一步上1阶,2阶，3阶，计算共有多少种不同的走法？...
Python爬楼梯问题:有n阶台阶,上楼可以一步上1阶,2阶,3阶,计算共有多少种不同的走法? 总共n步台阶(先假设n>3),f(n)表示n步台阶的走法总数 1.第一步如果是只走1步台阶,剩下的 ...
【算法题解】爱因斯坦楼梯 - 若每步上2阶，最后剩下1阶；若每步上3阶，最后剩2阶；若每步上5阶最后剩下4阶；若每步上6阶最后剩5阶；只有每步上7阶最后刚好一阶也不剩。请问该阶梯至少有多少阶
题目描述:爱因斯坦楼梯 - 有一个长阶梯,若每步上2阶,最后剩下1阶:若每步上3阶,最后剩2阶:若每步上5阶,最后剩下4阶:若每步上6阶,最后剩5阶:只有每步上7阶,最后刚好一阶也不剩.请问该阶梯至少 ...
爱因斯坦曾出过这样一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，则最后剩下5阶；只有每步跨7阶，最后才正好1阶不剩。参考例
爱因斯坦曾出过这样一道数学题:有一条长阶梯,若每步跨2阶,最后剩下1阶:若每步跨3阶,最后剩下2阶:若每步跨5阶,最后剩下4阶:若每步跨6阶,则最后剩下5阶:只有每步跨7阶,最后才正好1阶不剩.参考例 ...
爱因斯坦的题目：在你面前有一条长长的阶梯，如果每步跨2阶，那么最后剩1阶；如果每步跨3阶，那么最后剩2阶.....................
在你面前有一条长长的阶梯,如果每步跨2阶,那么最后剩1阶:如果每步跨3阶,那么最后剩2阶:如果每步跨5阶,那么最后剩4阶:如果每步跨6阶,最后剩5阶:只有当每步跨7阶时,最后才正好走完,一阶也不剩.请 ...
[C语言]程序改错题。爱因斯坦曾出过这样的一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶...
程序改错题.爱因斯坦曾出过这样的一道数学题:有一条长阶梯,若每步跨2阶,最后剩下1阶:若每步跨3阶,最后剩下2阶:若每步跨5阶,最后剩下4阶:若每步跨6阶,最后剩下5阶:只有每步跨7阶,最后才正好1阶 ...
算法017：三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。
题目:三步问题.有个小孩正在上楼梯,楼梯有n阶台阶,小孩一次可以上1阶.2阶或3阶.实现一种方法,计算小孩有多少种上楼梯的方式.结果可能很大,你需要对结果模1000000007.示例1:输入:n = ...
企业上云要几步？中拓互联奉送企业上云全攻略
企业上云要几步?中拓互联奉送企业上云全攻略不论是国家倡导的"上云用数赋智",还是由疫情引发的强烈需求,这两年成长型企业上云,可谓是如火如荼. 图片来源于:人民政府网虚无缥缈的一 ...
有一条长阶梯：如果每步跨 2阶，那么最后剩 1 阶；如果每步跨 3 阶，那么最后剩 2 阶；如果每步跨 5 阶，那么最后剩 4 阶；如果每步跨 6 阶，那么最后剩 5 阶；只有当每步跨 7 阶时，最后
才正好走完, 一阶不剩.请问这条阶梯至少有多个阶? #include <stdio.h> void main() { int n;for(n=7;n<1000;n++)if(n%7= ...

梯有N阶，上楼可以一步上一阶，也可以一次上二阶（Java实现）

梯有N阶，上楼可以一步上一阶，也可以一次上二阶（Java实现）相关推荐

最新文章

热门文章