算法五：动态规划（数字三角形、最长上升子序列、最长公共子序列、神奇的口袋、斐波那契数列记忆化搜索、数塔、最大连续子序列和、最长不下降子序列（LIS））

最新推荐文章于 2021-08-07 08:59:42 发布
最新推荐文章于 2021-08-07 08:59:42 发布
阅读量277 收藏 1
点赞数
分类专栏： 算法和数据结构 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44631615/article/details/105179814
版权

这次我换一种方式，先给出例题再归纳算法方法

例题一、数字三角形

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
递归代码如下：

#include<stdio.h>

#define MAX 101

int max(int a, int b)
{
	return a > b ? a : b;
}

int D[MAX][MAX];
int n;

int MaxSum(int i, int j)
{
	if(i == n)
		return D[i][j];
	int x = MaxSum(i + 1, j);
	int y = MaxSum(i + 1, j + 1);
	return max(x, y) + D[i][j];
}

int main()
{
	int i, j;
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= i; j++)
		{
			scanf("%d", &D[i][j]);
		}
	}
	printf("%d\n", MaxSum(1, 1));
	return 0;
}

在这里插入图片描述
为什么超时？
在这里插入图片描述
改进策略：
在这里插入图片描述
优化版：记忆递归型动归程序

#include<stdio.h>

#define Max 101

int max(int a, int b)
{
	return a > b ? a : b;
}

int D[Max][Max];
int n;
int maxSum[Max][Max];		//用来存放每一个数字到底边的最大和 

int MaxSum(int i, int j)
{
	if(maxSum[i][j] != -1)
		return maxSum[i][j];
	if(i == n)
		maxSum[i][j] = D[i][j];
	else
	{
		int x = MaxSum(i + 1, j);
		int y = MaxSum(i + 1, j + 1);
		maxSum[i][j] = max(x, y) + D[i][j];
	}
	return maxSum[i][j];
}

int main()
{
	int i, j;
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= i; j++)
		{
			scanf("%d", &D[i][j]);
			maxSum[i][j] = -1;
		}
	}
	printf("%d\n", MaxSum(1, 1));
	return 0;
}

递推方案：
在这里插入图片描述
详细C代码如下：

#include<stdio.h>

#define Max 101
int D[Max][Max];
int maxsum[Max][Max] = {0};

int max(int a, int b)
{
	return a > b ? a : b;
}

int main()
{
	int i, j;
	int n;
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= i; j++)
		{
			scanf("%d", &D[i][j]);
		}
	}
	for(i = 0; i <= n; i++)
	{
		maxsum[n][i] = D[n][i];
	}
	for(i = n - 1; i >= 1; i--)
	{
		for(j = 1; j <= i; j++)
			maxsum[i][j] = D[i][j] + max(maxsum[i + 1][j], maxsum[i + 1][j + 1]);
	}
	printf("%d\n", maxsum[1][1]);
	return 0;
}

我们可以把空间优化一下，把maxsum转化为一维数组，节省空间
在这里插入图片描述

#include<stdio.h>

#define Max 101

int max(int a, int b)
{
	return a > b ? a : b;
}

int D[Max][Max];
int maxsum[Max] = {0};

int main()
{
	int i, j;
	int n;
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= i; j++)
		{
			scanf("%d", &D[i][j]);
		}
	}
	
	for(i = 1; i <= n; i++)
		maxsum[i] = D[n][i];
	
	for(i = n - 1; i >= 1; i--)
	{
		for(j = 1; j <= i; j++)
		{
			maxsum[j] = D[i][j] + max(maxsum[j], maxsum[j + 1]);
		}
	}
	
	printf("%d\n", maxsum[1]);
	
	
	return 0;
}

这个题还可以进一步空间优化，指针法
让指针maxsum指向D[n]，把D[n]的首地址给maxsum，maxsum[1]就是D[n][1]，依次类推

#include<stdio.h>

#define Max 101
int D[Max][Max];
int n;
int *maxsum;

int max(int a, int b)
{
	return a > b ? a : b;
}

int main()
{
	int i, j;
	scanf("%d", &n);
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= i; j++)
		{
			scanf("%d", &D[i][j]);
		}
	}
	maxsum = D[n];
	for(i = n - 1; i >= 1; i--)
	{
		for(j = 1; j <= i; j++)
		{
			maxsum[j] = D[i][j] + max(maxsum[j], maxsum[j + 1]);
		}
	}
	printf("%d\n", maxsum[1]);
	return 0;
}

动归思路：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

动归的应用场景：

在这里插入图片描述

例题二、最长上升子序列

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
也就是说通过a数组承接输入的N个数据，maxLen数组记载以第i个数为最右端的最大子序列，相应得出最大子序列

详细C代码如下：

#include<stdio.h>

#define Max 1010
int a[Max];
int maxLen[Max];

#define max(a, b) (a > b ? a : b)

void sort(int a[], int n)
{
	int i, j;
	int t = 0;
	for(i = 1; i < n; i++)
	{
		for(j = i + 1; j < n + 1; j++)
		{
			if(a[i] > a[j])
			{
				t = a[j];
				a[j] = a[i];
				a[i] = t;
			}
		}
	}
}

int main()
{
	int N;
	scanf("%d", &N);
		
	int i, j;
	for(i = 1; i <= N; i++)
	{
		scanf("%d", &a[i]);
		maxLen[i] = 1;
	}
	
	for(i = 2; i <= N; i++)
	{
		for(j = 1; j < i; j++)
		{
			if(a[i] > a[j])
				maxLen[i] = max(maxLen[i], maxLen[j] + 1);
		}
	}
		
	sort(maxLen, N);
	printf("%d\n", maxLen[N]);
	
	return 0;
}

部分运行结果如下：
在这里插入图片描述
关于动态规划，蓝桥杯还有很多相关题目，可以参考该博文蓝桥杯2018第九届C语言B组省赛习题题解——习题D.测试次数*（经典递推）

例题三、最长公共子序列***

在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述
在这里插入图片描述
详细C代码如下：

#include<stdio.h>
#include<string.h>

char s1[1000];
char s2[1000];
int maxLen[1000][1000];

#define max(a, b) (a > b ? a : b)

int main()
{
	gets(s1);
	gets(s2);
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int i, j;
	for(i = 0; i <= len1; i++)
	{
		maxLen[i][0] = 0;
	}
	for(j = 0; j <= len2; j++)
	{
		maxLen[0][j] = 0;
	}
	
	for(i = 1; i <= len1; i++)
	{
		for(j = 1; j <= len2; j++)
		{
			if(s1[i - 1] == s2[j - 1])
			{
				maxLen[i][j] = maxLen[i - 1][j - 1] + 1;
			}
			else
			{
				maxLen[i][j] = max(maxLen[i - 1][j], maxLen[i][j - 1]); 
			}
		}
	}
	printf("%d\n", maxLen[len1][len2]);
	return 0;
}

部分运行结果如下：
在这里插入图片描述

例题四、神奇的口袋

在这里插入图片描述
在这里插入图片描述
递归法：

#include<stdio.h>

int a[30];
int N;

int Ways(int w, int k)		//w为需要凑的体积 
{
	if(w == 0)
		return 1;
	if(k <= 0)				//没有物品可选 
		return 0;
	return Ways(w, k - 1) + Ways(w - a[k], k - 1);
}				//不选第k种物品和选第k种物品 

int main()
{
	scanf("%d", &N);
	int i;
	for(i = 1; i <= N; i++)
	{
		scanf("%d", &a[i]);
	}
	printf("%d\n", Ways(40, N));
	return 0;
}

样例运行结果如下：
在这里插入图片描述
动归解法：

#include<stdio.h>
#include<string.h>

int main()
{
	int N;
	scanf("%d", &N);
	int ans[41][N + 1];
	int a[N + 1];
	memset(ans, 0, sizeof(ans));
	int i, j;
	for(j = 1; j <= N; j++)
	{
		scanf("%d", &a[j]);
		ans[0][j] = 1;
	}
	ans[0][0] = 1;	
	int v;
	
	for(v = 1; v <= 40; v++)
	{
		for(j = 1; j <= N; j++)
		{
			ans[v][j] = ans[v][j - 1];		
			if(v - a[j] >= 0)
				ans[v][j] += ans[v - a[j]][j - 1];
		}
	}
	
	printf("%d\n", ans[40][N]);
	return 0;
}

部分运行结果如下
在这里插入图片描述

斐波那契数列记忆化搜索

#include<bits/stdc++.h>
using namespace std;

#define maxn 100
int dp[maxn];

int F(int n)
{
	if(n == 0 || n == 1)
	{
		return 1;
	}
	if(dp[n] != -1)
	{
		return dp[n];
	}
	else
	{
		dp[n] = F(n - 1) + F(n - 2);
		return dp[n];
	}
} 

int main()
{
	memset(dp, -1, sizeof(int) * maxn);
	cout << F(5) << endl;
	return 0;
}

运行结果：
在这里插入图片描述

数塔

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1000;

int f[maxn][maxn], dp[maxn][maxn];

int main()
{
	int n;
	cin >> n;
	
	//输入数塔 
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= i; j++)
		{
			cin >> f[i][j];
		}
	}
	//底层边界 
	for(int j = 1; j <= n; j++)
	{
		dp[n][j] = f[n][j];
	}
	
	for(int i = n - 1; i >= 1; i--)
	{
		for(int j = 1;j <= i; j++)
		{
			dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]) + f[i][j];
		}
	}
	
	cout << dp[1][1] << endl;
	return 0;
}

样例运行结果：
在这里插入图片描述

最大连续子序列和

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;

const int maxn = 10010;
int A[maxn], dp[maxn];

int main()
{
	int n;
	cin >> n;
	for(int i = 0; i < n; i++)
	{
		cin >> A[i];
	}
	
	dp[0] = A[0];
	
	for(int i = 1; i < n; i++)
	{
		dp[i] = max(A[i], dp[i - 1] + A[i]); 
	}
	int k = 0;
	for(int i = 1; i < n; i++)
	{
		if(dp[i] > dp[k])
		{
			k = i;
		}
	}
	
	cout << dp[k] << endl;
	return 0;
}

样例运行结果：
在这里插入图片描述

最长不下降子序列（LIS）

#include<bits/stdc++.h>
using namespace std;

const int N = 100;
int A[N], dp[N];

int main()
{
	int n;
	cin >> n;
	for(int i = 1; i <= n; i++)
	{
		cin >> A[i];
	}
	
	int ans = -1;
	for(int i = 1; i <= n; i++)
	{
		dp[i] = 1;
		for(int j = 1; j < i; j++)
		{
			if(A[i] >= A[j] && (dp[j] + 1 > dp[i]))
			{
				dp[i] = dp[j] + 1;
			}
		}
		ans = max(ans, dp[i]);
	}
	cout << ans << endl;
	return 0;
}

样例运行结果：
在这里插入图片描述

最近我还会将算法博文更新丰富完善！如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持，下期更精彩！！！

源代码•宸
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DP专题 2 | LIS最长上升子序列 - POJ 2533
ACM算法日常
06-13 4116
这篇来看LIS~上题。 POJ - 2533 Longest Ordered Subsequence Description A numeric sequence ofaiis ordered ifa1<a2< ... <aN. Let the subsequence of the given numeric sequence (a1,a2, ....
算法面试通关40讲完整课件 44-53 动态规划
最新发布
07-06
5. **最长递增子序列**：找到数组中非降序子序列的最长长度。 6. **硬币找零**：给出不同面值的硬币，求解最少的硬币数量来凑成目标金额。 7. **编辑距离**：计算两个字符串之间的最小编辑操作次数，使其变成对方。 ...
动态规划小题整理（数字三角形，最长上升子序列，最长公共子序列）
an94460061的博客
03-23 260
我分析做动规的题目有两种方式： 1、记忆化递归性（递归+备忘录） 2、递推型 其中，记忆化递归性用递归的方式做，并且要设置备忘录数组，以免重复调用计算，浪费时间；递推型动规要确定出状态，并列出状态转移方程，这是比较难的。 下面三个小题都是有关动态规划的题目： 目录 一、数字三角形 二、最长上升子序列（百练2757） 三、最长公共子序列（poj1458） 一、数字三角形 Desc...
最长上升子数列
HPU留白的博客
08-09 561
最长上升子数列 输入 第1行：1个数N，N为序列的长度(2 <= N <= 50000) 第2 - N + 1行：每行1个数，对应序列的元素(-10^9 输出 输出最长递增子序列的长度。 输入示例 8 5 1 6 8 2 4 5 10 输出示例 5 题解（转载）：    (LIS Lo
动态规划--数字三角形，最长上升子序列，最长公共子序列
Destiny_suk的博客
12-05 364
本文部分内容转载自https://blog.csdn.net/baidu_28312631/article/details/47418773     动态规划相信大家都知道，动态规划算法也是新手在刚接触算法设计时很苦恼的问题，有时候觉得难以理解，但是真正理解之后，就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章，大多都是叙述概念，讲解原理，让人觉得晦涩难懂，即使一时间看...
动态规划(1) 数字三角形 最长上升子序列 最长公共子序列
衎的博客
08-11 220
1、记忆化数组 2.、动态规划思想 递归定义-&amp;amp;gt; 递推公式 思路 先走一步，看剩下的 递推公式 初值 递归出口 递推公式 递归体 一、数字三角形(POJ1163) 在上面的数字三角形中寻找一条从顶部到底边的路径，使得 路径上所经过的数字之和最大。路径上的每一步都只能往左下或 右下走。只需要求出这个最大和即可，不必给出具体路径...
算法与程序设计：第3章 动态规划2.pptx
06-01
- **斐波那契数列**：这是一个经典的动态规划问题，其中每个数是前两个数的和。通过数组存储先前计算的结果，避免了递归计算时的重复工作。 - **0-1背包问题**：在有限容量的背包中选择物品以最大化总价值，需要决定...
算法导论 动态规划
08-15
动态规划是一种强大的算法设计策略，特别适用于解决具有最优子结构和重叠子问题的最优化问题。通过合理的子问题划分、状态定义和递推关系设计，可以有效地解决复杂的问题。无论是理论研究还是实际应用，动态规划都...
算法设计与实现-动态规划
04-19
**数塔**问题是一个经典的动态规划实例，目标是从一个三角形数塔的顶部到底部找到一条路径，使得路径上的节点值之和最大。这个问题可以通过自底向上的方法解决，逐层计算每个节点的最大和，直到顶层。例如，一个5...
经典算法大全,包括河内之塔，费式数列，巴斯卡三角形，三色棋，老鼠走迷宫...
05-15
最常用的计算斐波那契数列的方法有递归、动态规划和矩阵快速幂等。 3. **帕斯卡三角形（Pascal's Triangle）**： 帕斯卡三角形是一种二维数列，每一行的数字是上一行相邻两个数字的和。它揭示了二项式系数的规律，...
动态规划，数字三角形 最大子段和问题 最长公共子序列
04-13
编程实现最大子段和问题的求解（分别采用分治法和动态规划法求解） 编程实现最长公共子序列(LCS)问题的求解 设计算法求解数字三角形问题，并编程实现。（P90算法实现题3－7）
查找最长连续数字串
12-06
输入一个字符串，从中找出最长的连续的数字串，返回数字串的长度。
最大上升子序列(LIS)
Diors
04-02 477
最大上升子序列问题有两种解法： 1.运用了DP的思想，当要判断第n个位置的最大上升子序列时要将n前面的数全部遍历一遍然后比较前面节点当前面节点的上升子序列+1大于当前节点的上升子序列则更新，时间复杂度为n*n。 代码如下: #include // DP using namespace std; #define N 40010 int dp[N]; int data[N]; int ma
最长上升子序列(动态规划递推,LIS)
weixin_34293141的博客
11-16 146
1759:最长上升子序列 题目: 总时间限制:2000ms内存限制:65536kB描述一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK &l...
2018.01.01(数字三角形，最长上升子序列等)
01-01 105
2017.12.24 简单的动态规划 1.数字三角形(算法引入) 题目描述：下图所示是一个数字三角形，其中三角形中的数值为正整数，现规定从最顶层往下走到最底层，每一步可沿左斜线向下或右斜线向下走。设三角形有n层，编程计算出从顶层到底层的一条路径，使得该路径上的和最大，输出最大值。(n<=100) 思路&&代码(搜索回溯)： 最显而易见的思路，既然要求一条...
线性dp例题详解——数字三角形、最长上升子序列、最长公共子序列、最短编辑距离、编辑距离
weixin_45627369的博客
08-07 183
数字三角形 1.状态表示dp[i][j] i.集合:所有从起点走到(i,j)的路径 ii.属性：Max 2.状态计算 为了方便计算，如果出现i-1这样的下标，最好i从1开始。 动态规划问题时间复杂度一般等于状态数量×转移计算量 做法：自顶向上 也可以自底向上做 #include <iostream> #include <algorithm> using namespace std; const int INF=1e9; const int N=510; int num[N][N]
[动态规划]数字三角形、最长上升子序列
Zoe的技术博客
07-10 673
POJ 1163 数字三角形7 3 8 8 1 0 2 7 4 4 4 5 2 6 5在上面的数字三角形中寻找一条从顶部到底边的路径, 使得路径上所经过的数字之和最大。路径上的每一步都 只能往左下或右下走。只需要求出这个最大和即可,不 必给出具体路径。 三角形的行数大于1小于等于100 数字为 0 - 99解法：这道题用递归做是解法很显然的：递归 设f(i,j) 为三角形上从
最长递增子序列问题的求解
yclinuxmyf的专栏
10-17 1436
　                                    最长递增子序列问题的求解　　最长递增子序列问题是一个很基本、较常见的小问题，但这个问题的求解方法却并不那么显而易见，需要较深入的思考和较好的算法素养才能得出良好的算法。　　一， 最长递增子序列问题的描述　　设L=是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=，其中k1　　二， 第一种算法：转化为LCS问题求解
最长连续序列
Coronia的博客
05-02 362
https://leetcode.com/problems/longest-consecutive-sequence/ 该题目要求从一个数组中找出可以组成的最长连续序列，即该序列的所有元素每次递增1，要求输出这个序列的长度。 首先将这个数组由大到小排序。之后通过遍历数组，比较当前元素和上一个的大小来判断是否为连续序列。判断的结果有三种：1、相差为1，则表明连续，计数值加1；2、相差为0
动态规划解决算法设计难题：斐波那契数列、数字三角形与矩阵优化
3. 二进制矩阵最大子方阵全1问题：通过二维动态规划，记录当前行和列的连续1子序列长度。递归方程可能为：dp[i][j] = dp[i-1][j-1] + A[i][j] (如果A[i][j]=1)，否则dp[i][j] = max(dp[i-1][j], dp[i][j-1])。时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值