斐波那契

递归式斐波那契函数

long long fib(long long k){if(k==1||k==2) return 1;return fib(k-1)+fib(k-2);
}

上述函数存在一定的问题，比如fib(n)=fib(n−1)+fib(n−2),fib(n−1)=fib(n−2)+fib(n−2)fib(n)=fib(n-1)+fib(n-2),fib(n-1)=fib(n-2)+fib(n-2)fib(n)=fib(n−1)+fib(n−2),fib(n−1)=fib(n−2)+fib(n−2)，其中fib(n−2)fib(n-2)fib(n−2)被计算了两次，层层递归下去，在nnn很大时有大量重复计算，算法效率很低，可能导致递归爆栈。

记忆化优化递归式斐波那契函数

我们只需要记录计算过的函数项，就可以提高算法效率。

long long data[101];//可记录斐波那契1~100项的值
long long fib(long long k){if(data[k]!=0) return data[k];//保存过函数值直接返回 if(k==1||k==2) data[k]=1;else data[k]=fib(k-1)+fib(k-2);return data[k];//返回上两行计算的函数值
}

递推式斐波那契函数

我们可以去掉递归，直接使用数组计算斐波那契函数

long long fib[101];//可记录斐波那契1~100项的值
long long init(){//fib[k]记录的是斐波那契第k项,使用fib数组要先调用init初始化fib数组 fib[1]=fib[2]=1;for(int i=3;i<=100;i++) fib[i]=fib[i-1]+fib[i];
}

基础动态规划

爬楼梯

题目描述

树老师爬楼梯，有一楼梯共nnn级，若每次只能跨上一级或者二级，要走上nnn级，共有多少种不同走法？
例如：楼梯一共有333级，他可以每次都走一级，或者第一次走一级，第二次走两级也可以第一次走两级，第二次走一级，一共333种方法。

输入格式

输入包含若干行，每行包含一个正整数NNN，代表楼梯级数，1≤N≤301\le N\le 301≤N≤30

输出格式

不同的走法数，每一行输入对应一行输出。

样例输入

5
8
10

样例输出

8
34
89

题解

每次可以走111步或222步，所以走第nnn步(n≥3)(n\ge 3)(n≥3)时可以看做从n−1n-1n−1走111步或从n−2n-2n−2走222步，走第nnn步方案数就等于前222步方案数之和。

#include <iostream>
using namespace std;
int main(){long long num[31];num[1]=1;num[2]=2;for(int i=3;i<=30;++i) num[i]=num[i-1]+num[i-2];int n;while(cin>>n){cout<<num[n]<<endl;}
}

骨牌铺法

题目描述

有1∗n1*n1∗n的一个长方形，用一个 1∗11*11∗1、1∗21*21∗2和1∗31*31∗3的骨牌铺满方格。

例如当n=3n=3n=3时，共有444种铺法。如下图：

输入格式

一个整数nnn，表示1∗n1*n1∗n的长方形。

输出格式

一个整数表示方法总数。

样例输入

样例输出

数据范围与提示

1<n<=401<n<=40 1<n<=40

题解

每次可以铺111格、222格或333格，所以铺nnn格(n≥4)(n\ge 4)(n≥4)时可以看做从n−1n-1n−1格、n−2n-2n−2格或n−3n-3n−3格开始铺，铺nnn格方案数就等于n−1n-1n−1格、n−2n-2n−2格、n−3n-3n−3格方案数之和。

#include <iostream>
using namespace std;
int main(){long long num[41];num[1]=1;num[2]=2;num[3]=4;for(int i=4;i<=40;++i) num[i]=num[i-1]+num[i-2]+num[i-3];int n;while(cin>>n){cout<<num[n]<<endl;}
}

爬台阶

题目描述

HHH老师爬台阶，他可以每步上111个或222个台阶，输入台阶的级数，求不同的走法数。

例如：n=3n=3n=3，台阶有333个台阶，他可以每步爬111个台阶，或者第111步爬111个台级，第222步爬222个台阶，也可以第111步爬222个台阶，第222步爬111个台阶，一共333种爬法。

但不幸的是，台阶上有kkk个台阶烂了，HHH老师不能踩在这些台阶上，现在给出台阶的级数nnn和烂的kkk个台阶，请你计算他上台阶的方法总数。

输入格式

第111行是两个n,kn,kn,k，代表台阶数和烂台阶的数目。

第222行是kkk个1∼n1\sim n1∼n的整数，表示烂台阶。

输出格式

不同的走法数。

样例输入

5 1
4

样例输出

数据范围与提示

100%的数据满足：1≤n≤60,0≤k<n100\%的数据满足：1\le n \le 60, 0\le k<n 100%的数据满足：1≤n≤60,0≤k<n

题解

每次可以走111步、222步或333步，所以走nnn步(n≥4)(n\ge 4)(n≥4)时可以看做从n−1n-1n−1步、n−2n-2n−2步或n−3n-3n−3步开始走，走nnn步方案数就等于n−1n-1n−1步、n−2n-2n−2步、n−3n-3n−3步方案数之和，如果是烂台阶，则第nnn步方案数位000。

#include <iostream>
#include <algorithm>
using namespace std;
int main(){int n,k,p;long long num[101];num[0]=1;cin>>n>>k;for(int i=0;i<k;i++){cin>>p;num[p]=-1;//标记p为烂台阶}for(int i=1;i<=n;i++){if(i==1){if(num[i]==-1) num[i]=0;//烂台阶else num[1]=1;}else{if(num[i]==-1) num[i]=0;//烂台阶else num[i]=num[i-1]+num[i-2];}}if(num[n]==-1) printf("%lld\n",num[n-1]);else printf("%lld\n",num[n]);return 0;
}

二维动态规划

矩阵行走

题目描述

给定一个n∗mn*mn∗m的矩阵，问从左上角的交叉点走到右下角的交叉点有多少条不同的路径（同一路径不允许重复走，也不允许往回走）。

输入格式

一行两个正整数n,mn,mn,m

输出格式

路径数目ttt

样例输入

6 4

样例输出

数据范围与提示

1≤n≤101≤m≤41\le n \le 10\\ 1\le m\le 4 1≤n≤101≤m≤4

题解

走到(i,j)(i,j)(i,j)时，实际上是从(i−1,j)(i-1,j)(i−1,j)或(i,j−1)(i,j-1)(i,j−1)走过来的，所以路线数是从左或上走过来的路线数相加

#include <iostream>
using namespace std;
int main(){long long num[11][5];//记录走到(i,j)时路线数int n,m;cin>>n>>m;//走第一行第一列都是1条路线for(int j=0;j<=m;j++) num[0][j]=1;for(int i=0;i<=n;i++) num[i][0]=1;for(int i=1;i<=n;i++)for(int j=1;j<=m;j++){num[i][j]=num[i-1][j]+num[i][j-1];//可以从左或上走,方案数是左和上之和}cout<<num[n][m];//输出走到终点的路线数
}

走格子

题目描述

一个N×NN×NN×N的网格，你一开始在(1,1)(1,1)(1,1)，即左上角。每次只能移动到下方相邻的格子或者右方相邻的格子，问到达(N,N)(N,N)(N,N)，即右下角有多少种方法。

但是这个问题太简单了，所以现在有MMM个格子上有障碍，即不能走到这MMM个格子上。

输入格式

输入文件第111行包含两个非负整数N,MN, MN,M，表示了网格的边长与障碍数。

接下来MMM行，每行两个不大于NNN的正整数x,yx,yx,y。表示坐标(x,y)(x,y)(x,y)上有障碍不能通过，且有1≤x,y≤n1≤x,y≤n1≤x,y≤n，且x,yx, yx,y至少有一个大于111，并请注意障碍坐标有可能相同。

输出格式

一个非负整数，为答案mod100003mod 100003mod100003后的结果。

输入样例

3 1
3 1

输出样例

数据范围与提示

对于100100%100的数据，有N≤1000,M≤100000N≤1000,M≤100000N≤1000,M≤100000。

题解

解法类似于上题矩阵行走，区别就是如果(i,j)(i,j)(i,j)是障碍物，则走到(i,j)(i,j)(i,j)的路线数为000

#include<iostream>
using namespace std;
const int MAXN=1005;//数组大小
const int MOD=100003;//模
int n,m;
int a[MAXN][MAXN];//递推数组
bool flg[MAXN][MAXN];//标记数组
int main(){cin>>n>>m;//输入while(m--){int x,y;cin>>x>>y;flg[x][y]=1;//标记}a[1][1]=1;//初始值为1for(int i=1;i<=n;i++){//两层循环枚举方格for(int j=1;j<=n;j++){//同上a[i][j]+=a[i-1][j]+a[i][j-1];//递推式if(flg[i][j]==1) a[i][j]=0;//判断a[i][j]=a[i][j]%MOD;//模100003}}cout<<a[n][n];//输出路径总数return 0;
}

杨辉三角形

题目描述

杨辉三角形在组合数学中占有重要地位，与组合数、二项式定理等重要内容有关，如下图所示就是一个杨辉三角形：

通常用一个二维数组C[i][j]C[i][j]C[i][j]按右边示意图来存储杨辉三角形。C[i][j]C[i][j]C[i][j]表示第iii行第jjj列的数字。
注意：行号从000开始编号，列号也从000开始编号。

输入格式

一行两个整数i,ji,ji,j。

输出格式

输出C[i][j]C[i][j]C[i][j]的值，即杨辉三角形的第iii行第jjj列的元素。

样例输入

5 3

样例输出

数据范围与提示

0≤i≤60,0≤j≤i0\le i\le 60, 0\le j\le i 0≤i≤60,0≤j≤i

题解

实际上杨辉三角形可以看作是一个下三角形矩阵，每行第一个和最后一个元素是1，中间的元素是上方元素与左上元素之和。

#include <iostream>
#include <algorithm>
using namespace std;
const int N=62;
const int MOD=100003;
int main(){long long num[N][N];num[0][0]=num[1][0]=num[1][1]=1;int n,m;cin>>n>>m;for(int i=2;i<=n;i++){num[i][0]=1;for(int j=1;j<=i-1;j++){num[i][j]=num[i-1][j]+num[i-1][j-1];}num[i][i]=1;}cout<<num[n][m];
}

动态规划-数字三角形模型

数字三角形

题目描述

有一个由非负整数组成的三角形，第一行只有一个数，除了最下行之外每个数的左下方和右下方各有一个数。

        73   88   1   02   7   4   4
4   5   2   6   5

从第一行的数开始，每次可以往左下或右下走一格，直到走到最下行，把沿途经过的数全部加起来。如何走才能使得这个和尽量大？

输入格式

第一行输入整数nnn表示三角形的层数。

在接下来的nnn行中，每一行表示三角形的中每一行整数，整数之间以空格隔开。

输出格式

输出三角形从第一行的数到最后一行数所经过的数字之和的最大值。

样例输入

样例输出

数据范围与提示

1≤n≤500−10000≤三角形中的整数≤100001\le n\le 500\\ -10000\le 三角形中的整数\le 10000 1≤n≤500−10000≤三角形中的整数≤10000

题解

两种动态规划设计方式,设num[i][j]num[i][j]num[i][j]表示(i,j)(i,j)(i,j)项的值

dp[i][j]dp[i][j]dp[i][j]表示从(1,1)(1,1)(1,1)走到(i,j)(i,j)(i,j)的最大值,dp[i][j]=max(dp[i−1][j−1],dp[i−1][j])+num[i][j]dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+num[i][j]dp[i][j]=max(dp[i−1][j−1],dp[i−1][j])+num[i][j]

#include <iostream>
#include <algorithm>
using namespace std;
#define N 1001
int dp[N][N];
int main(){int n;int ret;cin>>n;for(int i=1;i<=n;i++){for(int j=1;j<=i;j++){cin>>dp[i][j];if(j==1) dp[i][j]+=dp[i-1][j];else if(j==i) dp[i][j]+=dp[i-1][j-1];else dp[i][j]+=max(dp[i-1][j-1],dp[i-1][j]);if(i==n){if(j==1) ret=dp[i][j];else ret=max(ret,dp[i][j]);}}}cout<<ret;
}

dp[i][j]dp[i][j]dp[i][j]表示从最后一行走到(i,j)(i,j)(i,j)的最大值,dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+num[i][j]dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+num[i][j]dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+num[i][j]

#include <iostream>
#include <algorithm>
using namespace std;
#define N 1001
int dp[N][N];
int main(){int n;int ret;cin>>n;for(int i=1;i<=n;i++){for(int j=1;j<=i;j++){cin>>dp[i][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]);}}cout<<dp[1][1];
}

动态规划-最长上升子序列模型

最长上升子序列

题目描述

设有由n(1≤n≤1000)n(1\le n\le 1000)n(1≤n≤1000)个不相同的整数组成的数列，

记为 : b(1)、b(2)、…、b(n)b(1)、b(2)、\dots、b(n)b(1)、b(2)、…、b(n)若存在i1<i2<⋯<iei_1<i_2<\dots<i_ei1<i2<⋯<ie且有b(i1)≤b(i2)≤⋯≤b(ie)b(i_1)\le b(i_2)\le \dots \le b(i_e)b(i1)≤b(i2)≤⋯≤b(ie)则称为长度为eee的不下降序列。

程序要求，当原数列出之后，求出最长的不下降序列。

例如13，7，9，16，38，24，37，18，44，19，21，22，63，1513，7，9，16，38，24，37，18，44，19，21，22，63，1513，7，9，16，38，24，37，18，44，19，21，22，63，15。

例中13，16，18，19，21，22，6313，16，18，19，21，22，6313，16，18，19，21，22，63就是一个长度为777的不下降序列，同时也有7，9，16，18，19，21，22，637 ，9，16，18，19，21，22，637，9，16，18，19，21，22，63组成的长度为888的不下降序列。

输入格式

第一行包含整数NNN。

第二行包含NNN个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

输入样例

14
13 7 9 16 38 24 37 18 44 19 21 22 63 15

输出样例

数据范围与提示

1≤N≤1000−109≤数列中的数≤1091\le N \le 1000\\ -10^9 \le 数列中的数 \le 10^9 1≤N≤1000−109≤数列中的数≤109

题解

用dp[i]dp[i]dp[i]表示以下标iii结尾时最长上升长度，则dp[i]=max(dp[j])+1(j<i,b[j]≤b[i])dp[i]=max(dp[j])+1(j<i,b[j]\le b[i])dp[i]=max(dp[j])+1(j<i,b[j]≤b[i])

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define N 1001
int dp[N];
int num[N];
int main() {int n,mLen = 0;cin>>n;for(int i=0;i<n;i++) {cin>>num[i];}for(int i=0;i<n;i++) {dp[i]=1;for(int j=0;j<i;j++) {if(num[j]<=num[i]){dp[i]=max(dp[i],dp[j]+1);}}mLen=max(mLen,dp[i]);}cout<<mLen;
}

最长公共子序列

题目描述

给定两个长度分别为NNN和MMM的字符串AAA和BBB，求既是AAA的子序列又是BBB的子序列的字符串长度最长是多少。

输入格式

第一行包含两个整数NNN和MMM。

第二行包含一个长度为NNN的字符串，表示字符串AAA。

第三行包含一个长度为MMM的字符串，表示字符串BBB。

字符串均由小写字母构成。

输出格式

输出一个整数，表示最大长度。

输入样例

4 5
acbd
abedc

输出样例

数据范围与提示
1≤N≤10001\le N \le 1000 1≤N≤1000

题解

用dp[i][j]dp[i][j]dp[i][j]表示A,BA,BA,B分别取前i,ji,ji,j长度时最长公共子序列长度。
显然A[i]==B[j]A[i]==B[j]A[i]==B[j]时dp[i][j]=dp[i−1][j−1]+1dp[i][j]=dp[i-1][j-1]+1dp[i][j]=dp[i−1][j−1]+1，A[i]≠B[j]A[i]\ne B[j]A[i]=B[j]时dp[i][j]=max(dp[i−1][j],dp[i][j−1])dp[i][j]=max(dp[i-1][j],dp[i][j-1])dp[i][j]=max(dp[i−1][j],dp[i][j−1])

#include <iostream>
#include <string>
using namespace std;
#define N 1001
int dp[N][N];
char s1[N],s2[N];
int main()
{int n1,n2;scanf("%d%d%s%s",&n1,&n2,s1+1,s2+1);//+1是因为保留下标0for(int i=0;i<=n1;i++){for(int j=0;j<=n2;j++){if(i==0||j==0){dp[i][j]=0;//有下标0是空串continue;}if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1]+1;else{dp[i][j]=max(dp[i-1][j],dp[i][j-1]);}}}printf("%d",dp[n1][n2]);return 0;
}

动态规划-背包问题

01背包

题目描述

有NNN件物品和一个容量是VVV的背包。每件物品只能使用一次。

第iii件物品的体积是viv_ivi，价值是wiw_iwi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行两个整数，N,VN,VN,V，用空格隔开，分别表示物品数量和背包容积。

接下来有NNN行，每行两个整数vi,wiv_i,w_ivi,wi，用空格隔开，分别表示第iii件物品的体积和价值。

题解
用dp[i][j]dp[i][j]dp[i][j]表示取前iii个物品装入最大容量为jjj的背包所获得最大价值。

j−v[i]>=0j-v[i]>=0j−v[i]>=0表示能装下物品iii，dp[i][j]=max(dp[i−1][j],dp[i−1][j−v[i]]+w[i])dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i])dp[i][j]=max(dp[i−1][j],dp[i−1][j−v[i]]+w[i])，maxmaxmax的两项分别表示装货不装物品iii
j−v[i]<0j-v[i]<0j−v[i]<0表示不能装下物品iii，dp[i][j]=dp[i−1][j]dp[i][j]=dp[i-1][j]dp[i][j]=dp[i−1][j]

#include <iostream>
#define maxL 1001
using namespace std;
int main(){int dp[maxL][maxL],v[maxL],w[maxL];//dp[i][j]表示选取i号背包使用j空间的最大价值 int n,maxW;cin>>n>>maxW;for(int i=1;i<=n;i++) cin>>v[i]>>w[i];for(int i=0;i<=n;i++){for(int j=0;j<=maxW;j++){if(i==0||j==0) dp[i][j]=0; else if(j<v[i]) dp[i][j]=dp[i-1][j];else dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);}}cout<<dp[n][maxW];return 0;
}

完全背包

题目描述

有NNN种物品和一个容量是VVV的背包，每种物品都有无限件可用。

第iii种物品的体积是viv_ivi，价值是wiw_iwi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数N,VN,VN,V，用空格隔开，分别表示物品种数和背包容积。

接下来有NNN行，每行两个整数vi,wiv_i,w_ivi,wi，用空格隔开，分别表示第iii种物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

输入样例

输出样例

数据范围与提示
0<N,V≤10000<vi,wi≤10000<N,V\le 10000<v_i,w_i\le 1000 0<N,V≤10000<vi,wi≤1000

题解
以01背包问题为基础，用dp[i][j]dp[i][j]dp[i][j]表示取前iii个物品装入最大容量为jjj的背包所获得最大价值。
j−k∗v[i]>=0j-k*v[i]>=0j−k∗v[i]>=0表示能装下kkk个物品iii，dp[i][j]=max(dp[i−1][j−k∗v[i]]+k∗w[i])dp[i][j]=max(dp[i-1][j-k*v[i]]+k*w[i])dp[i][j]=max(dp[i−1][j−k∗v[i]]+k∗w[i])

#include <iostream>
using namespace std;
#define N 10001
int dp[N][N];
int v[N],w[N];
int n,V;
int main(){cin>>n>>V;for(int i=1;i<=n;i++){cin>>v[i]>>w[i];//输入}for(int i=1;i<=n;i++){for(int j=1;j<=V;j++){for(int k=0;k*v[i]<=j;k++){dp[i][j]=max(dp[i][j],dp[i-1][j-k*v[i]]+k*w[i]);//求如何装入可得到最大的dp[i][j]}}}cout<<dp[n][V];
}

版权声明

本文档归cout0所有，仅供学习使用，未经允许，不得转载。

【C++】递推动态规划基础入门相关推荐

蓝桥杯第39级台阶递推动态规划
网上答案写的都和狗屎一样.看不下去.自己写一个描述如下小明刚刚看完电影<第39级台阶>,离开电影院的时候,他数了数礼堂前的台阶数,恰好是39级! 站在台阶前,他突然又想着一个问题:如果 ...
蓝桥杯算法训练 Cowboys 递推动态规划
问题描述一个间不容发的时刻:n个牛仔站立于一个环中,并且每个牛仔都用左轮手枪指着他旁边的人!每个牛仔指着他顺时针或者逆时针方向上的相邻的人.正如很多西部片那样,在这一刻,绳命是入刺的不可惜--对峙的 ...
基础算法整理（1）——递归与递推
程序调用自身的编程技巧称为递归( recursion).递归做为一种算法在程序设计语言中广泛应用. 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一 ...
递归、递推、贪心、搜索和动态规划
文章目录递归与递推动态规划与递归贪心算法与动态规划知乎关于动态规划问题的一个问答总结! 参考文献递归与递推递归:函数调用自身,直到达到基线条件之后,再一层层的回归到最初的问题.这是一种自顶 ...
算法设计分析之------ 递推与递归篇二
递推与递归篇二递归 Secret Cow Code S 黑白棋子的移动递推(动态规划) 覆盖墙壁递归 Secret Cow Code S 题目链接:Secret Cow Code S 解题思路 ...
递推（一）：递推法的基本思想
所谓递推,是指从已知的初始条件出发,依据某种递推关系,逐次推出所要求的各中间结果及最后结果.其中初始条件或是问题本身已经给定,或是通过对问题的分析与化简后确定. 利用递推算法求问题规模为n的解的基本思 ...
动态规划入门之dp递推～
欢迎访问https://blog.csdn.net/lxt_Lucia-- 宇宙第一小仙女\(^o^)/--萌量爆表求带飞=≡Σ((( つ^o^)つ~ dalao们点个关注呗-- 本篇文章重在递推,不 ...
【披着递推皮的动态规划】山区建小学题解
今天小编随意写了一道老师布置的题,这是一道看起来很普通的题,我却不明白它为什么放在递推中-- 废话不多说,直接看题. ▍1197:山区建小学 [题目描述] 政府在某山区修建了一条道路,恰好穿越总共m个 ...
动态规划的递归写法和递推写法
动态规划是一种非常精妙的算法思想,它没有固定的写法,极其灵活,常常需要具体问题具体分析什么是动态规划动态规划(Dynamic Programming,DP)是一种用来解决一类最优化问题的算法思想. ...

【C++】递推动态规划基础入门

斐波那契

递归式斐波那契函数

记忆化优化递归式斐波那契函数

递推式斐波那契函数

基础动态规划

爬楼梯

骨牌铺法

爬台阶

二维动态规划

矩阵行走

走格子

杨辉三角形

动态规划-数字三角形模型

数字三角形

动态规划-最长上升子序列模型

最长上升子序列

最长公共子序列

动态规划-背包问题

01背包

完全背包

版权声明

【C++】递推动态规划基础入门相关推荐

最新文章

热门文章