70. Climbing Stairs

题目描述（简单难度）

爬楼梯，每次走 1 个或 2 个台阶，n 层的台阶，总共有多少种走法。

解法一 暴力解法

用递归的思路想一下，要求 n 层的台阶的走法，由于一次走 1 或 2 个台阶，所以上到第 n 个台阶之前，一定是停留在第 n - 1 个台阶上，或者 n - 2 个台阶上。所以如果用 f ( n ) 代表 n 个台阶的走法。那么，

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

f ( 1 ) = 1，f ( 2 ) = 2 。

发现个神奇的事情，这就是斐波那契数列（Fibonacci sequence）。

直接暴力一点，利用递归写出来。

public class Climbing_Stairs {
	
	public static int climbstairs(int n) {
		
		if(n==1) return 1;
		if(n==2) return 2;
		
		return climbstairs(n-1)+climbstairs(n-2);
	}
	
	public static void main(String args[]) {
		int n=6;
		int ans=climbstairs(n);
		System.out.println(ans);
	}
}

间复杂度：是一个树状图， $O\left(2^n\right)$。

空间复杂度：

解法二 暴力解法优化

解法一很慢，leetcode 上报了超时，原因就是先求 climbstairs( n - 1 )，然后求 climbstairs( n - 2 ) 的时候，其实很多解已经有了，但是它依旧进入了递归。优化方法就是把求出的解都存起来，后边求的时候直接使用，不用再进入递归了。叫做 memoization 技术。

import java.util.HashMap;

public class Climbing_Stairs2 {
	
	public static int climbStairN(int n,HashMap<Integer,Integer> hashMap) {
		
		if(n==1) return 1;
		if(n==2) return 2;
		
		int n1=0;
		if(!hashMap.containsKey(n-1)) {
			n1=climbStairN(n-1,hashMap);
			hashMap.put(n-1, n1);
		}else {
			n1=hashMap.get(n-1);
		}
		
		int n2=0;
		if(!hashMap.containsKey(n-2)) {
			n2=climbStairN(n-2,hashMap);
			hashMap.put(n-2, n2);
		}else {
			n2=hashMap.get(n-2);
		}
		return n1+n2;
		
	}
	public static void main(String args[]) {
		int n=6;
		HashMap<Integer,Integer> hashMap = new HashMap<Integer,Integer>();
		int ans=climbStairN(n,hashMap);
		System.out.println(ans);
	}
}

时间复杂度：

空间复杂度：

当然由于 key 都是整数，我们完全可以用一个数组去存储，不需要 Hash。

import java.util.HashMap;

public class Climbing_Stairs3 {
	
	public static int climbStairsN(int n, int[] memo) {
		
	    if (n == 1) return 1;
	    
	    if (n == 2) return 2;
	    
	    int n1 = 0;
	    //数组的默认值是 0
	    if (memo[n - 1] == 0) {
	        n1 = climbStairsN(n - 1, memo);
	        memo[n - 1] = n1;
	    } else {
	        n1 = memo[n - 1];
	    }
	    
	    int n2 = 0;
	    if (memo[n - 2] == 0) {
	        n2 = climbStairsN(n - 2, memo);
	        memo[n - 2] = n2;
	    } else {
	        n2 = memo[n - 2];
	    }
	    
	    return n1 + n2;
	}
	
	public static void main(String args[]) {
		int n=5;
		int[] memo=new int[n];
		int ans=climbStairsN(n,memo);
		System.out.println(ans);
	}
}

解法三 迭代

当然递归可以解决，我们可以直接迭代，省去递归压栈的过程。初始值 f ( 1 ) 和 f ( 2 )，然后可以求出 f ( 3 )，然后求出 f ( 4 ) … 直到 f ( n )，一个循环就够了。其实就是动态规划的思想了。

public class Climbing_Stairs4 {
	
	public int climb(int n) {
		if(n==1) return 1;
		if(n==2) return 2;
		int n1=1,n2=2;
		
		for(int i=3;i<=n;i++) {
			int temp=n2;
			n2=n1+n2;
			n1=temp;
		}
		return n2;
	}
}

时间复杂度：O（n）。

空间复杂度：O（1）。

python版本

class Solution(object):
    def climbStairs(self, n):

        if(n==1):
            return 1
        if(n==2):
            return 2
        if(n==3):
            return 3

        n1=1
        n2=2

        for i in range(3,n+1):
            temp=n2
            n2=n1+n2
            n1=temp
        return n2