Leetcode: 70. Climbing Stairs(Week1, Easy)

注： 本文使用三种方法实现Fibonacci Sequence：递归法、非递归法、矩阵快速幂法

---

Leetcode 70
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?
Note: Given n will be a positive integer.

• 题意：

  • 本题描述的是一个爬楼梯问题，你需要n steps才能到达最高点，而每次你只能跨1~2个steps，问你有多少种到达最高点的走法？

• 思路：

  • 假设我k次到达楼顶，那么当我完成第k-1次时，第k次有两种情况：1 steps or 2 steps ( 注：k与本题解题无关，定义它只是为了方便说明最后一次有1-steps和2-steps两种情况)。所以，假设n steps到达楼顶有F(n)种走法，那么显然F(n) = F(n-1)+F(n-2)。看到这个通项，立刻就反应过来，这道题考察的是斐波那契数列。

  • 虽然通项出来了，还是要看看前几项。不难分析，F(1) = 1, F(2) = 2, F (3) = 3。这说明只用到斐波那契的一部分，即从斐波那契数列第二项开始，而不包含第一项。这一点在写代码是要注意。

• 解题：

  • 递归写法，十分简练，但效率极低，显然会超时！

  • 时间复杂度分析需要用到二阶常系数齐次差分方程相关知识，看这里

    class Solution {
    public:
    int climbStairs(int n) {
    if (n == 0) return 1;
    if (n == 1) return 1;
    return climbStairs(n-1) + climbStairs(n-2);
    }
    };

  • 非递归写法，时间复杂度为O(n), 本题可以通过！

    class Solution {
    public:
    int climbStairs(int n) {
        //if (n == 0) return 1;
        //if (n == 1) return 1;
        //return climbStairs(n-1) + climbStairs(n-2);
        if (n == 1) return 1;
        int a[n+1];
        a[0] = 1;
        a[1] = 1;
        for (int i = 2; i <= n; i++) {
            a[i] = a[i-1] + a[i-2];
        }
        return a[n];
    }
    };

除了以上两种方法，斐波那契数列还可以通过矩阵快速幂法求解。

• 先谈谈快速幂(Fast Exponentiation)：

  • 快速幂就是快速算底数的n次幂，时间复杂度O(log N)

  • 例如2^10, 常规计算需要9次乘法(2*2*2…*2)，而使用快速幂，只需要2次。

  • 10的二进制表示：1010, 对应为2^3,2^2,2^1,2^0, 即有1的位对应2^3, 2^1

  • 2^10 = 2^8 * 2^2 = 2^(2^3) * 2^(2^1) 指数部分刚好对应10的二进制

  • 以上就是快速幂的核心思想，下面是我自己写的一个快速幂：

    /*
    2017/9/8: Fast_Exponentiation.cpp 快速幂
    原理：
    eg：10的二进制表示：1010, 对应为2^3,2^2,2^1,2^0
    2^10 = 2^8 * 2^2 = 2^(2^3) * 2^(2^1) 指数部分刚好对应10的二进制
     */
    
    # include <iostream>
    
    
    using namespace std;
    
    int main(void) {
        // base： 底
        // e： 幂
        // result： 计算结果
        int base, e; 
        int result = 1;
        int count = 0;
    
        cin >> base >> e;
    
        // 快速幂算法核心部分
        while(e) {
            if (e & 1) { // 判断最后一位是否为1
                result = result * base;
            }
            base = base * base;
            e = e >> 1;
            count++;
        }
        cout << "The result is: " << result << endl;
        cout << "The num of the loop is " << count << endl;
        return 0;
    }

• 斐波那契数列也可以快速幂的思想实现，只不过它的快速幂是用于矩阵，即矩阵快速幂算法，下面是我自己写的一个程序：

• 

  /*
  2017/9/8 Fibonacci.cpp
  思路：利用矩阵快速幂的思路解题
   */
  
  
  # include <iostream>
  
  
  # include <cstring>
  
  
  using namespace std;
  
  typedef long long ll;
  
  // 定义矩阵
  struct Matrix {
      ll m[2][2];
  };
  
  // 矩阵幂的底
  Matrix base = {0, 1, 1, 1};
  
  // 矩阵乘法
  Matrix multi(const Matrix& A, const Matrix&B) {
      Matrix result;
      memset(result.m, 0, sizeof(result));
      for (int i = 0; i < 2; i++) {
          for (int j = 0; j < 2; j++) {
              for (int k = 0; k < 2; k++) {
                  result.m[i][j] += A.m[i][k]*B.m[k][j];
              }
          }
      }
      return result;
  }
  
  // 矩阵的N次方，矩阵快速幂的核心
  Matrix power(int N) {
      Matrix result = {1, 0, 0, 1};
      while(N) {
          if (N & 1) {
              result = multi(result, base);
  /*          for (int i = 0; i < 2; i++) {
                  cout << endl;
                  for (int j = 0; j < 2; j++) {
                      cout << result.m[i][j] << " ";
                  }
              }
  */
          }
          base = multi(base, base);
          N >>= 1;
      }
      return result;
  }
  
  // 计算，调用子函数
  ll calcu(int N) {
      if (N == 0) return 0;
      int e = N-1;
      Matrix p = power(e);
      ll result = p.m[1][0]*0 + p.m[1][1]*1;
      return result;
  }
  
  // 主函数
  int main(void) {
      int N;
      cin >> N;
  
      ll result;
      result = calcu(N);
  
      cout << "The result is " << result << endl;
      return 0;
  }

---

以上内容皆为本人观点，欢迎大家提出批评和指导，我们一起探讨！

---