动态规划之滚动数组

       实际上，滚动数组应用的条件是基于递推或递归的状态转移中，反复调用当前状态前的几个阶段的若干个状态，而每一次状态转移后有固定个数的状态失去作用。滚动数组便是充分利用了那些失去作用的状态的空间填补新的状态，一般采用求模(%)的方法来实现滚动数组。

        举个求斐波那契数列的例子吧。其中采用了一个dp数组，实际上可以改为只使用dp[0]、dp[1]、dp[2]这3个元素空间，采用求模来实现。对应的算法如下:

int Fib()
{
    int dp[3];
    dp[1] = 1;
    dp[2] = 1;
    for(int i = 3;i <= n;i++)
    {
        dp[i % 3] = dp[(i - 2) % 3] + dp[(i - 1) % 3];
    }
    return dp[n % 3];
}

     例题:一个楼梯有n个台阶，上楼可以一步上一个台阶，也可以一步上两个台阶，求上楼梯共有多少种不同的走法。

     思路:设f(n)表示上n个台阶的楼梯的走法数。显然f(1) = 1,f(2) = 2(一种走法是一步上一个台阶，走两步，另外一种走法是一步上两个台阶).

             对于大于2的n个台阶的楼梯，一种走法是第一步上一个台阶，剩余n-1个台阶的走法数是f(n-1)；另外一种走法是第一步上两个台阶，剩余n-2个台阶的走法数是f(n-2),所以有f(n)=f(n-1)+f(n-2)。对应的状态转移方程如下:

      或者

用一维动态规划数组dp[n](下标从0开始)存放f(n+1)(下标从1开始).采用左边的状态转移方程。对应的求解算法如下:

int solve()
{
    dp[0] = 1;
    dp[1] = 2;
    for(int i = 2;i < n;i++)
    {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n - 1];
}

        但dp[i]只与dp[i-1]和dp[i-2]两个子问题解相关，共3个状态,所以采用滚动数组，将dp数组设置为dp[3],对应的完整程序如下:

#include <iostream>
using namespace std;
//问题表示
int dp[3];
int solve1()
{
    dp[0] = 1;
    dp[1] = 2;
    for(int i = 2;i < n;i++)
    {
        dp[i % 3] = dp[(i - 1) % 3] + dp[(i - 2) % 3];
    }
    return dp[(n - 1) % 3];
}
void main()
{
    n = 10;
    cout << solve1(3) << endl;//输出结果为89
}

        其他二维数组及高维数组也可以做这样的改进。例如，一个采用普通方法实现的算法如下:

        

void solve()
{
    int dp[MAX][MAX];
    memset(dp,0,sizeof(dp));
    for(int i = 1;i < MAX;i++)
    {
        for(int j = 1;j < MAX;j++)
        {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
}

        若MAX为1000，上面的方案需要1000 * 1000的空间,而dp[i][j]只依赖于dp[i-1][j]和dp[i][j-1],所以可以使用滚动数组,对应的算法如下:

        

void solve1()
{
    int dp[2][MAX];
    memset(dp,0,sizeof(dp));
    for(int i = 1;i < MAX;i++)
    {
        for(int j = 0;j < MAX;j++)
        {
            dp[i % 2][j] = dp[(i - 1) % 2] + dp[i % 2][j - 1];
        }
    }
}

        改用滚动数组后仅仅使用了2 * 1000的空间就获得1000 * 1000空间相同的效果。