蓝桥杯之动态规划入门

入门思路：dfs暴力-->记忆化搜索-->递推dp （逐步优化算法）

推荐B站大佬 一只会code的小金鱼

递归的判断

1.一个问题的解可以分解为几个子问题的解。
2.这个问题与分解之后的子问题,除了数据规模不同,求解思路完全一样。
3.存在基线/终止条件。

精典例题：爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 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;
}

1. dp[i-1]: 这表示如果不抢第i个房屋，那么到第i-1个房屋为止可以获得的最大金额。换句话说，它是前i-1个房屋中可以抢劫到的最大金额，不包括第i个房屋。

2. dp[i-2] + a[i]: 这表示如果决定抢第i个房屋，由于不能连续抢劫相邻的房屋（会触发警报），所以最后一次抢劫是在第i-2个房屋或之前。因此，这部分的金额是到第i-2个房屋为止可以获得的最大金额加上第i个房屋中的金额。

3. 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])