递归、迭代、到动态规划

一、递归 VS迭代

---

首先，一起来看下这几道经典面试题：

1. 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

2. 一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

   先看第1题：

   • 先走f(n-1),剩一级台阶我们一步跨上去。
   • 先走f(n-2),剩两级台阶我们一次跨两部上去。（一次跨一步的话就属于上面第一种类型了）。
     

我们可以很快得到递归关系式：f(n) = f(n-1)+f(n-2).显然这是斐波拉契数列；
得到递推关系式后，我们很快能写出如下代码：

int jumpFloor(int number) 
{
    if(number <= 1)
    {
        return 1;
    }
    return jumpFloor(n-1) + jumpFloor(n-2);
}

是不是很简单？但是，如果你去OJ上一跑，就会发现运行超时；显然面试官不太能出这么简单的题。在oj的测试用例中，一定准备了很多的测试用例让你的程序栈溢出。那么接下来该怎么办呢？这就到了体现了迭代的优势了，下面看代码。

    int jumpFloor(int number) {
        if(number <= 1)
            {
                return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int cur;
        while(number > 1)
            {
            cur = f1 + f2;
            f1 = f2;
            f2 = cur;
            number--;
        }
        return cur;
    }

---

二、动态规划VS迭代

是不是也不难？那么这种解法就真的那么完美了吗？我们如法炮制，来看看第二道题：

*算法分析：*
- 我们先按照前面的分析写出递归关系式f(n) = f(n-1) + f(n-2) +…+f(1) ;
- 在上面的题目中我们用了两个变量保存f的f(n-1)和f(n-2)的值，当需要求解f（n）的时候我们可以直接用这两个变量求得f(n);
- 那么到了问题二中，类推的话我们是不是需要n个变量来保存前n个f(n)的值？其实这就很接近动态规划了。下面看代码：

class Solution {
public:
    int jumpFloorII(int number) {

             if(number <= 1)
                 {
                    m_table[0] = 1;
                    m_table[1] = 1;
                        return 1;
                }
             int i = 1;

             while(number >= i)
                 {
                 if(!m_table[number])
                     {
                        m_table[number] += jumpFloorII(number-i); 
                    }
                 else{
                        m_table[number] += m_table[number-i];
                        }
                 i++;
             }
        return m_table[number];
    }
 private:
    int *m_table = new int[32786]; 
};
//（以上为c++代码，如果简单地在本地跑的话，可以把私有变量改成全局变量，或者用参数传递进去）

*算法分析：*
我们在私有成员里定义了一个表用于存储已经递归算过的子问题，然后当子问题交叉的时候；比如f(5) = f(4) + f(3)+…+f(1) 与f(4) = f(3) + f(2) + f(1)就有三个交叉子问题。

• 我们如果在算f(5)的时候要递归地去求f(4)，f(3) ， f(2) ， f(1)；而在求f(4)的时候又递归地去求f(3) ， f(2) ， f(1)；这样下去调用的栈是一个可怕的数。
• 不难发现，我们在求f(4)的时候如果记录下f(4)，f(3) ， f(2) ， f(1)的值，那么我们在f(5)的时候就可以不用任何递归直接得出结果。