动态规划(1)--青蛙跳台阶

动态规划
例子一：
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个n级台阶总共有多少种跳法。

分析：
第一步：
假设台阶有7阶的话，先从正向分析，假如先跳了一阶，那么还有六阶可选，假如先挑了二阶，就还有五阶可选。所以可以得出，在青蛙做出一个动作后会有f(7) = f(6) + f(5);
第二步
在青蛙做出第二步动作时，先假设青蛙第一次只跳了一阶，此时剩六阶台阶，又演变成了我们第一步的动作，于是便有f(6)=f(5) + f(4)，以此类推；
第三步
总有一天，青蛙会跳到只剩一阶或两阶的情况，此时便是我们需要解决的边界问题，f(2) = 2,f(1) = 1;

问题解决。代码实现如下：

class Solution
{
public:
    int jump(int &nums)
    {
        if (nums <= 0)
        {
            return 0;
        }
        if (nums == 1)
        {
            return 1;
        }
        if (nums == 2)
        {
            return 2;
        }
        int i = 0;
        int *value =  new int[nums + 1];
        value[0] = 0;
        value[1] = 1;
        value[2] = 2;
        for (i = 3; i <= nums;i++)
        {
            value[i] = value[i - 1] + value[i - 2];
        }
        return value[nums];
    }
};

int main()
{
    Solution A;
    int a = 7;
    cout << A.jump(a);
}

例子二：
一只青蛙一次可以跳上任意台阶。求该青蛙跳上一个n级台阶总共有多少种跳法

分析：
第一步：
假设台阶有7阶的话，先从正向分析，假如先跳了一阶，那么还有六阶可选，假如先挑了二阶，就还有五阶可选。以此类推所以可以得出，在青蛙做出一个动作后会有f(7) = f(6) + f(5) + f(4) + f(3) + f(2) + f(1);
第二步：
找出边界，f(1) = 1,f(2)=2;
用同样的方法解决了跳n阶的问题，代码实现如下：

#include <iostream>
using namespace std;

class Solution
{
public:
    int jump(int &nums)
    {
        if (nums <= 0)
        {
            return 0;
        }
        if (nums == 1)
        {
            return 1;
        }
        if (nums == 2)
        {
            return 2;
        }
        int i = 0;
        int *value =  new int[nums + 1];//存放nums台阶时的方法
        value[0] = 0;
        value[1] = 1;
        value[2] = 2;
        for (i = 3; i <= nums;i++)
        {
            value[i] = 0;
            for (int j = 0; j < i; j++)
            {
                value[i] = value[i] + value[j] ;
            }
            value[i] = value[i] + 1;//+1是统计青蛙一次跳起nums阶时的情况
        }
        return value[nums];
    }
};

int main()
{
    Solution A;
    int a = 7;
    cout << A.jump(a);
    system("pause");
}