入门思路:dfs暴力-->记忆化搜索-->递推dp (逐步优化算法)
推荐B站大佬 一只会code的小金鱼
递归的判断
1.一个问题的解可以分解为几个子问题的解。
2.这个问题与分解之后的子问题,除了数据规模不同,求解思路完全一样。
3.存在基线/终止条件。
精典例题:爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2
输出:2
解释:有两种方法可以爬到楼顶。
- 1 阶 + 1 阶
- 2 阶
示例 2:
输入:n = 3
输出:3
解释:有三种方法可以爬到楼顶。
- 1 阶 + 1 阶 + 1 阶
- 1 阶 + 2 阶
- 2 阶 + 1 阶
略加思索发现
递归:dfs暴力
递归的过程:“归”的过程(自底 向上)才是产生答案的过程,"递"的过程(自顶向下)是分解子问题的过程。
递归搜索树的底:最小问题的解----->最大问题的解
#include <stdio.h>
#include <stdlib.h>
int climbStairs(int n){
if(n<0) return 0;
if(n==1) return 1;
if(n==2) return 2;
//可以直接if(n<=2) return n;
return climbStairs(n-1)+climbStairs(n-2);
}
int main() {
int n;
scanf("%d",&n);
printf("%d",climbStairs(n));
return 0;
}
这段代码在处理大数值时可能会出现效率问题,因为它会重复计算相同的子问题,导致时间复杂度较高o(2^n)。我们尝试将重复计算保存。
记忆化递归(找一个一维数组将重复计算的结果存储起来)(拿空间换时间)
#include <stdio.h>
#include <stdlib.h>
int m[50];
int climbStairs(int n){
int res;
if(n<0) return 0;
if(m[n]!=0) return m[n];
//可以直接if(m[n]) return m[n];
else
{
res = climbStairs(n-1)+climbStairs(n-2);
return res;
}
}
int main() {
int n,i;
for(i=0;i<50;i++) m[i]=0;
m[1]=1;m[2]=2;
scanf("%d",&n);
printf("%d",climbStairs(n));
return 0;
}
dp:动态规划是递归的子集!
#include <stdio.h>
#include <stdlib.h>
int climbStairs(int n) {
if (n <= 2) {
return n;
}
int *dp = (int *)malloc((n + 1) * sizeof(int));
//分配了一个大小为 (n + 1) 的整型数组的内存空间或直接int dp[50];
dp[1] = 1;
dp[2] = 2;//递推数组的初始值=递归(dfs)的边界
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];//这个递推公式也就是dfs的状态转移公式(向下递归公式)1:1
}
//时间复杂度小多了
int result = dp[n];
free(dp);
return result;
}
int main() {
int n;
scanf("%d", &n);
printf("%d", climbStairs(n));
return 0;
}
//还可以进行空间优化(滚动数组)
int newf = 0, tmp1 = 1, tmp2 = 2;
for (int i = 3; i <= n; i++) {
newf = tmp1 + tmp2;
tmp1 = tmp2;
tmp2 = newf;
}
printf("%d\n",newf);
大盗阿福:
#include <stdio.h>
#include <stdlib.h>
int a[100001] = { 0 }, dp[100001] = { 0 };
int max(int a, int b) {
return (a > b) ? a : b;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
dp[0] = 0;
dp[1] = a[1];
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + a[i]);
}//关键就是厘清三量关系 正推或反推
printf("%d\n", dp[n]);
}
return 0;
}
-
dp[i-1]
: 这表示如果不抢第i
个房屋,那么到第i-1
个房屋为止可以获得的最大金额。换句话说,它是前i-1
个房屋中可以抢劫到的最大金额,不包括第i
个房屋。 -
dp[i-2] + a[i]
: 这表示如果决定抢第i
个房屋,由于不能连续抢劫相邻的房屋(会触发警报),所以最后一次抢劫是在第i-2
个房屋或之前。因此,这部分的金额是到第i-2
个房屋为止可以获得的最大金额加上第i
个房屋中的金额。 -
max(dp[i-1], dp[i-2] + a[i])
: 最后,这行代码通过比较上述两种情况,选择金额更大的一种作为到第i
个房屋为止可以获得的最大金额。这样,dp[i]
就被计算出来了,表示考虑前i
个房屋时可能获得的最大金额。
小总结:
求子问题和:dp[i] = dp[i - 1] + dp[i - 2]
求最优子问题:max(dp[i-1], dp[i-2] + a[i])