剑指 Offer 10- I. 斐波那契数列变种

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

class Solution(object):
    def fib(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 0 or n == 1:
            return n
        i = 0
        j = 1
        sum = 0
        for k in range(n):
            sum = i + j
            i = j
            j = sum
        return i%int(1e9+7)

class Solution {
    public int fib(int n) {
        if(n == 1 || n == 0) {
            return n;
        }
        long i = 0;
        long j = 1;
        long fb = 0;
        for(int b = 2; b <= n; b++) {
            fb = i + j;
            fb = (long)(fb % (1e9+7));
            i = j;
            j = fb;
        }
        
        return (int)fb;
    }
}

青蛙跳台阶问题

青蛙跳台阶问题，实质上就是动态规划，假设最后一跳（第n次）是一个台阶，或者两个台阶，往旧历史推演，那么第(n-1)次是几个台阶，第(n-2)次，…，第1次。
可以用递归版本的代码先看一下：

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

但是递归版本会由于函数栈过多溢出甚至超时，所以需要转为迭代版本。

Java版代码：

class Solution {
    public int numWays(int n) {
        if(n == 1 || n == 0) {
            return 1;
        }
        int i = 1;
        int j = 1;
        int sum = 0;
        while(n >= 2) {
            sum = i + j;
            sum = sum % (1000000007);
            i = j;
            j = sum;
            n -= 1;
        }
        return sum;
    }
}

python版代码：

class Solution(object):
    def numWays(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 0 or n == 1:
            return 1
        i = 1
        j = 1
        sum = 0
        for k in range(2, n+1, 1):
            sum = i + j
            i = j
            j = sum
        return sum % (1000000007)