爬楼梯问题

简述：

需要爬N层的楼梯，有max种爬楼梯方式，需要求算总共爬到N层 有几种方法

1. 回溯是比较直观的，就是一层一层向上叠加，走到顶层就是一种方法，得到结果

2. 一维动态规划的话， 就是用一个数组保留走过的楼层，比如最大步伐是3， 然后我现在考虑走到第10层有几种走法

就是 resultArray[10] = resultArray[ 10 - 1] + resultArray[10 - 2] + resultArray[10 - 3] 三者之和

3. 3解法中优化了2中的空间复杂度，用取余的方式实现f(n) = f(n - 1) + f(n - 2) + ... + f(n - k)

例子：

爬4层楼梯 ， 则N=4， 有3种步伐，分别为1步，2步，3步

则总共方法7种，一次为

1 + 1 + 1 + 1

1 + 1 + 2

1 + 2 + 1

1 + 3

2 + 1 + 1

2 + 2

3 + 1

算法实现1(回溯法）：

使用函数压栈， 不断累加当前楼梯的高度，深度探测是否已经爬到顶了，如果爬到顶了，那么count++，没有那么继续爬，并把步子压到stack中记录步伐顺序

package dynamic_programming;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Stack;

public class ClimbTheFloor {
private static int count = 0;
private static Stack<Integer> stack = new Stack<Integer>();
private static ArrayList<String> resultList = new ArrayList<String>();
public static void main(String[] args) {
InputStream inputStream = System.in;
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferReader = new BufferedReader(inputStreamReader);

//Get limited height
System.out.print("Please Input the Max height: ");
Integer max = null;
try{
max = Integer.parseInt(bufferReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

//Get the max step
System.out.print("Please Input the limited step: ");
Integer limit = null;
try{
limit = Integer.parseInt(bufferReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

Climb(0, max, limit);
System.out.println("There are " + count + " methods !");
for(String record : resultList)
System.out.println(record);
}

public static void Climb(int height, int max, int limit){
if(height == max){
count++;
resultList.add(stack.toString());
}
else{
for(int i = 1;i <= limit; i++)
if(height + i <= max){
stack.push(i);
Climb(height + i, max, limit);
stack.pop();
}
}
}
}

输出：



2） 动态规划实现：

package dynamic_programming;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ClimbTheFloor2 {
public static void main(String[] args) {
InputStream inputStream = System.in;
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferReader = new BufferedReader(inputStreamReader);

//Get limited height
System.out.print("Please Input the Max height: ");
Integer max = null;
try{
max = Integer.parseInt(bufferReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

//Get the max step
System.out.print("Please Input the limited step: ");
Integer limit = null;
try{
limit = Integer.parseInt(bufferReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

System.out.println("Number of Methods: " + CountMethods(max, limit));
}

/*
* @ Height : the height of the destination
* @ max : the max number of steps you can climb upstairs once
*/

private static int CountMethods(int max, int limit){
int resultArray[] = new int[max + 1];
resultArray[0] = 1;
for(int i = 1;i <= max;i++){
int sum = 0;
for(int j = 1;j <= limit;j++){
if(i - j < 0)
break;
else{
sum += resultArray[i - j];
}
}
resultArray[i] = sum;
}
return resultArray[max];
}
}

输出：



3） 优化了2）中的空间复杂度， 将空间降到了O(k) , 其中k为可以走的步数的种类

package dynamic_programming;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class ClimbTheFloor3 {
public static void main(String[] args) {
InputStream inputStream = System.in;
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

Integer limit = null;
try{
System.out.print("Please Input Limited step:");
limit = Integer.parseInt(bufferedReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

Integer max = null;
try{
System.out.print("\nPlease Input Max Height: ");
max = Integer.parseInt(bufferedReader.readLine());
}catch(IOException e){
e.printStackTrace();
}

ClimbTheFloor3 obj = new ClimbTheFloor3();
System.out.print("\nMethods: " + obj.CountMethods(max, limit));
}

private int CountMethods(int max, int limit){
if(max < 0 || limit < 0)
throw new IllegalArgumentException("Wrong arguments! ");

int step[] = new int[limit];
for(int i = 0; i < limit; i++)
step[i] = 1;
for(int i = 1; i <= max; i++){
int sum = 0;
for(int j = 0; j < limit; j++){
if(i - (j + 1) == 0){
sum++;
break;
}
sum += step[(i - (j + 1)) % limit];
}
step[(i - 1) % limit] = sum;
}
return step[(max - 1) % limit];
}
}

输出：