从暴力递归到记忆化搜索再到动态规划

在洛谷或者力扣刷动态规划的题，总是想破脑袋也想不出状态转移方程是怎么写出来，看答案很多人都写出来了，这时候就开始怀疑自己的智商了，一个简单的题的动态转移方程都不会，最近看了左神的讲解，才明白这其中是有套路存在的。
例子：有一个硬币面值数组arr，比如[100,24,35,76,50]，再给出一个目标值比如1000，每个硬币适用不限量，问你有多少种组合方法，使得总和为目标值。
接下来将一步步的阐述暴力递归是如何到动态规划转移的。
1.暴力递归基本思路：首先我们要明确可变参数是什么，要将所有的可变参数找出来，本题中的可变参数为选的是哪一个面值的钱用序号index表示，以及剩下的还有多少目标值需要达到用rest表示。函数process(index,rest)表示从序号index开始，要达到rest有多少种方法，主函数里就调用process(0,1000)表示。代码如下：

int process1(int index,int rest)
{
    if(rest < 0)
    {
        return 0;
    }
    if(index == num)
    {
        //如果index来到最后一个面值，判断当前的rest是否等于0
        return rest ==0?1:0;
    }
    int ways=0;
    for(int zhang=0;zhang*arr[index]<=rest;zhang++)
    {
        ways+=process1(index+1,rest-zhang*arr[index]);//解空间树横向扫描
    }
    return ways;
}
int way1()
{
    int res = process1(0,target);
    cout<<res<<endl;
}

2.将暴力递归改为记忆化搜索，简单来讲就是把return的返回值更新dp数组

int dp[MAX][MAX];//可变参数数组初始化值为-1表示我之前还没有遇到过这种情况
void init()
{
    for(int i=0;i<MAX;i++)
    {
        for(int j=0;j<MAX;j++)
        {
            dp[i][j]=-1;
        }
    }
}
int process2(int index,int rest)
{
    //记忆化搜索 上一个代码return的返回值更新dp
    if(dp[index][rest]!=-1)
    {
        return dp[index][rest];//以前出现过，直接返回
    }
    if(index == num)
    {
        //如果index来到最后一个面值，判断当前的rest是否等于0
        dp[index][rest] = rest==0?1:0;
        return dp[index][rest];
        //return rest ==0?1:0;
    }
    int ways=0;
    for(int zhang=0;zhang*arr[index]<=rest;zhang++)
    {
        ways+=process1(index+1,rest-zhang*arr[index]);//解空间树横向扫描
    }
    dp[index][rest] = ways;
    return dp[index][rest];

}
int way2()
{
    init();//初始化函数
    int res = process2(0,target);
    cout<<res<<endl;
}

3.将记忆化搜索改完动态规划

int dp2[MAX][MAX];
int process3()
{
    //动态规划，还是照着上面的代码进行修改
    dp2[num][0]=1;
    for(int index=num-1;index>=0;index--)
    {
        for(int rest=0;rest<=target;rest++)
        {
            int ways=0;
            for(int zhang=0;zhang*arr[index]<=rest;zhang++)
            {
                ways+=dp2[index+1][rest-zhang*arr[index]];//把暴力递归调用的函数换成dp
            }
            dp2[index][rest]=ways;
        }
    }
    return dp2[0][target];
}
void way3()
{
    int res = process3();
    cout<<res<<endl;
}

4.进一步优化动态规划
如图，如果我们当前来到面值为3，index为10的某个单元格，在同一层可以发现也存在重复计算，右边的那个值可以从左边和下边来，于是得到转移方程：dp[index][rest] = dp[index][rest-arr[index]]+dp[index+1][rest]如果rest-arr[index]>=0。很多题解直接给出这个方程，其实他们也是这么过来的，但是麻烦就不会告诉你这么去想

int dp3[MAX][MAX];
int process4()
{
    //动态规划，还是照着上面的代码进行修改
    dp3[num][0]=1;
    for(int index=num-1;index>=0;index--)
    {
        for(int rest=0;rest<=target;rest++)
        {
            dp3[index][rest]=  dp3[index+1][rest];
            if(rest-arr[index]>=0)
            {
                dp3[index][rest]+=dp3[index][rest-arr[index]];//把暴力递归调用的函数换成dp
            }
        }
    }
    return dp3[0][target];
}
void way4()
{
    int res = process4();
    cout<<res<<endl;
}

全部代码如下：

#include<bits/stdc++.h>
#define MAX 100
using namespace std;
int arr[MAX];
int num;//输入数组
int target;
int process1(int index,int rest)
{
    if(index == num)
    {
        //如果index来到最后一个面值，判断当前的rest是否等于0
        return rest ==0?1:0;
    }
    int ways=0;
    for(int zhang=0;zhang*arr[index]<=rest;zhang++)
    {
        ways+=process1(index+1,rest-zhang*arr[index]);//解空间树横向扫描
    }
    return ways;
}
void way1()
{
    int res = process1(0,target);
    cout<<res<<endl;
}
int dp[MAX][MAX];//可变参数数组初始化值为-1表示我之前还没有遇到过这种情况
void init()
{
    for(int i=0;i<MAX;i++)
    {
        for(int j=0;j<MAX;j++)
        {
            dp[i][j]=-1;
        }
    }
}
int process2(int index,int rest)
{
    //记忆化搜索 上一个代码return的返回值更新dp
    if(dp[index][rest]!=-1)
    {
        return dp[index][rest];//以前出现过，直接返回
    }
    if(index == num)
    {
        //如果index来到最后一个面值，判断当前的rest是否等于0
        dp[index][rest] = rest==0?1:0;
        return dp[index][rest];
        //return rest ==0?1:0;
    }
    int ways=0;
    for(int zhang=0;zhang*arr[index]<=rest;zhang++)
    {
        ways+=process1(index+1,rest-zhang*arr[index]);//解空间树横向扫描
    }
    dp[index][rest] = ways;
    return dp[index][rest];

}
void way2()
{
    init();//初始化函数
    int res = process2(0,target);
    cout<<res<<endl;
}
int dp2[MAX][MAX];
int process3()
{
    //动态规划，还是照着上面的代码进行修改
    dp2[num][0]=1;
    for(int index=num-1;index>=0;index--)
    {
        for(int rest=0;rest<=target;rest++)
        {
            int ways=0;
            for(int zhang=0;zhang*arr[index]<=rest;zhang++)
            {
                ways+=dp2[index+1][rest-zhang*arr[index]];//把暴力递归调用的函数换成dp
            }
            dp2[index][rest]=ways;
        }
    }
    return dp2[0][target];
}
void way3()
{
    int res = process3();
    cout<<res<<endl;
}
int dp3[MAX][MAX];
int process4()
{
    //动态规划，还是照着上面的代码进行修改
    dp3[num][0]=1;
    for(int index=num-1;index>=0;index--)
    {
        for(int rest=0;rest<=target;rest++)
        {
            dp3[index][rest]=  dp3[index+1][rest];
            if(rest-arr[index]>=0)
            {
                dp3[index][rest]+=dp3[index][rest-arr[index]];//把暴力递归调用的函数换成dp
            }
        }
    }
    return dp3[0][target];
}
void way4()
{
    int res = process4();
    cout<<res<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>num>>target;
    for(int i=0;i<num;i++)
    {
        cin>>arr[i];
    }
    way1();//暴力递归
    way2();//记忆化搜索
    way3();//动态规划
    way4();//动态规划优化
    return 0;
}

测试结果: