爬楼梯-ClimbingStairs

题目描述：

70. 爬楼梯

难度简单1975

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

通过次数604,724提交次数1,138,931

解决思想：

总结规律：n的种数=n-1的种数+n-2的种数；
那就递归啦；

直接递归太慢，因为有大量重复性操作：

    /**
       * 爬楼梯：
       * 总结规律：n的种数=n-1的种数+n-2的种数；
       * 那就递归啦；
       * 然而，这种写法，每一次的climbStairs()方法的参数都会导致从该参数递归到1和2一遍，大量的重复性操作；
       * @param n
       * @return
       */
      public static int climbStairs(int n) {
            int out = 0;
            if (n == 1) {
                  return 1;
            } else if (n == 2) {
                  return 2;
            } else {
                  out = climbStairs(n - 1) + climbStairs(n - 2);
                  return out;
            }
      }

这种写法，每一次的climbStairs()方法的参数都会导致从该参数递归到1和2一遍，大量的重复性操作；

测试时发现速度特别慢。

解决办法：将每一次计算之后的数值保存起来，下次直接拿来用就行了；

代码：

package zyh.springcloud.chapter2.service.impl.algorithm;

import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

/**
 * @ClassName ClimbingStairs
 * @Author zhangyonghui
 * @Description 爬楼梯
 * @Date 2021/11/4 16:59
 * @Version 1.0
 **/
public class ClimbingStairs {

      public static void main(String[] args) {
            int n = 45;
            long start = System.currentTimeMillis();
            int out = climbStairs2(n);
            long end = System.currentTimeMillis();
            System.out.println("耗时 = " + (end - start));
            System.out.println("out = " + out);
      }



      /**
       * 上述方案存在重大缺陷，每一次的climbStairs()方法的参数都会导致从该参数递归到1和2一遍，大量的重复性操作；
       * 解决办法：将每一次计算之后的数值保存起来，下次直接拿来用就行了；
       * @param n
       * @return
       */

      private static Map<Integer, Integer> hashMap = new HashMap<>();
      //private static Deque<Integer> stack = new LinkedList<>();
      static {
            hashMap.put(1, 1);
            hashMap.put(2, 2);
            //stack.push(1);
            //stack.push(2);
      }

      public static int climbStairs2(int n) {
            if (hashMap.containsKey(n)) {
                  return hashMap.get(n);
            }else{
                 // Integer pop = stack.pop();
                  //for (int i = pop+1; i <= n; i++) {
                  for (int i = 3; i <= n; i++) {
                        if (!hashMap.containsKey(i)) {
                              int stairs = climbStairs2(i - 1) + climbStairs2(i - 2);
                              hashMap.put(i, stairs);
                              //stack.push(i);
                        }
                  }
                  return  hashMap.get(n);
            }
      }

}

如果for循环不想用3开始，还可以用个辅助栈进行操作，不过可能消耗更多内存，进栈操作可能也费时，没测试具体耗时。