leetcode-climbing stairs

Climbing Stairs

  Total Accepted: 36520  Total Submissions: 107274 My Submissions

Question  Solution 

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

public class Solution {
    /*The bottom-up recursive*/
    public int climbStairs(int n) {
        if(n==0)return 0;
        if(n==1)return 1;
        if(n==2)return 2;
        int oneToEnd=1;
        int twoToEnd=2;
        int all=0;
        for(int i=2;i<n;i++){
            all=oneToEnd+twoToEnd;
            oneToEnd=twoToEnd;
            twoToEnd=all;
        }
        return all;
        
    }
}

public class Solution {
    
    public int climbStairs(int n) {
        int[] t= new int[n+1];  // should be one larger, and the initial value of t[n] is 0
        return countStep(n,t);
        
    }
    public int countStep(int n,int[] t){
        if(n==0)t[0]=0;
        if(n==1)t[1]=1;
        if(n==2)t[2]=2;
        /*T[n] does not need to be computed again*/
        else if(n>=3&&t[n]==0)t[n]=countStep(n-2,t)+countStep(n-1,t);
        return t[n];
    }
}

DP问题的特点：

1.大问题的子问题之间是相互关联的。

2.不用递归，用非递归算法，把子问题的答案记录在一个表内。

思路主要有两个;

1 bottom-up : 用iterative的方法来计算每一个小问题的答案，需要的子问题有几个，我们的表就有多大。

2 up-bottom： 用 recursive 的方法，这个问题之前有几个小问题，就需要多大的表，当子问题的结果以求出的时候，就不需要再递归了。

动态规划问题的重点就是子问题的划分。