1 动态规划
递推写法:自底向上;递归写法:自顶向下
一个问题必须拥有重叠子问题和最优子结构,才能用动态规划去解决。
1.1 分治与动态规划
共同点:都是将问题分解为子问题,然后合并子问题的解得到原问题的解。
不同点:分治法解决的问题不拥有重叠子问题,而动态规划解决的问题拥有重叠子问题;分治法解决的问题不一定是最优化问题,而动态规划解决的问题一定是最优化问题。
1.2 贪心与动态规划
共同点:都要求原问题必须拥有最优子结构
不同点:动态规划是从边界开始向上得到目标问题的解,贪心不一定得到最优解
2 最大连续子序列和
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=10010;
int a[maxn],dp[maxn]; //a[i]存放序列,dp[i]存放以a[i]结尾的连续序列的最大和
int main(){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%d",&a[i]);
//边界
dp[0]=a[0];
for(int i=i;i<n;i++){
//状态转移方程
dp[i]=max(a[i],dp[i-1]+a[i]);
}
//得到dp数组的最大值
int k=0;
for(int i=1;i<n;i++){
if(dp[i]>dp[k])
k=i;
}
printf("%d\n",dp[k]);
return 0;
}
3 最长不下降子序列LIS
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=10010;
int a[maxn],dp[maxn];
int main(){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
int ans=-1;
for(int i=0;i<n;i++){
dp[i]=1;
for(int j=0;j<i;j++){
if(a[j]<=a[i]&&dp[j]+1>dp[i])
dp[i]=dp[j]+1; //状态转移方程,用以更新dp[i]
}
ans=max(ans,dp[i]);
}
printf("%d",ans);
return 0;
}
4 最长公共子序列LCS
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=100;
char a[N],b[N];
int dp[N][N];
int main(){
int n;
gets(a+1); //从下标为1开始读入
gets(b+1);
int lena=strlen(a+1); //读取长度也从+1开始
int lenb=strlen(b+1);
//边界
for(int i=0;i<=lena;i++)
dp[i][0]=0;
for(int j=0;j<=lenb;j++)
dp[0][j]=0;
//状态转移方程
for(int i=1;i<=lena;i++){
for(int j=1;j<=lenb;j++){
if(a[i]==b[j])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
}
}
//dp[lena][lenb]是答案
printf("%d\n",dp[lena][lenb]);
return 0;
}
5 最长回文子串
#include<stdio.h>
#include<string.h>
const int maxn=1010;
char s[maxn];
int dp[maxn][maxn]; //dp[i][j]表示从i到j是否有回文串
int main(){
gets(s);
int len=strlen(s),ans=1; //ans是当前最长回文子串长度
//边界
for(int i=0;i<len;i++){
dp[i][i]=1;
if(i<len-1){
if(s[i]==s[i+1]){
dp[i][i+1]=1;
ans=2;
}
}
}
//状态转移方程
for(int l=3;l<len;l++){ //枚举子串长度
for(int i=0;i+l-1<len;i++){ //枚举子串的起始端点
int j=i+l-1; //子串的右端点
if(s[i]==s[j]&&dp[i+1][j-1]==1){
dp[i][j]=1;
ans=l; //更新最长回文子串长度
}
}
}
printf("%d\n",ans);
return 0;
}
6 DAG最长路
const int maxn=1010;
const int inf=1000000000;
int n; //顶点数
int g[maxn][maxn]; //g[i][j]存储从i到j的边权
int dp[maxn]={0}; //dp[i]存储以i为起点的最长路径长度
int choice[maxn]={-1}; //choice[i]存储以i为起点的最长路径后继结点
int DP(int i){
if(dp[i]>0) return dp[i]; //如果dp[i]已计算得到
for(int j=0;j<n;j++){ //遍历i的所有出边
if(g[i][j]!=inf){
int temp=DP(j)+g[i][j]; //单独计算,防止if中调用DP函数两次
if(temp>dp[i]){ //可以获得更长的路径
dp[i]=temp; //覆盖dp[i]
choice[i]=j;
}
}
}
return dp[i];
}
//调用printPath前需要先得到最大的dp[i],然后将i作为路径起点传入
void printPath(int i){
printf("%d",i);
while(choice[i]!=-1){
i=choice[i];
printf("->%d",i);
}
}
7 背包问题
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=100; //物品最大件数
const int maxv=1000;//V的上限
int w[maxn],c[maxn],dp[maxv];
int main(){
int n,V;
scanf("%d%d",&n,&V);
for(int i=0;i<n;i++)
scanf("%d",&w[i]);
for(int i=0;i<n;i++)
scanf("%d",&c[i]);
//边界
for(int v=0;v<=V;v++)
dp[v]=0;
for(int i=1;i<=n;i++){
for(int v=V;v>=w[i];v--)
dp[v]=max(dp[v],dp[v-w[i]]+c[i]);
}
// for(int i=1;i<=n;i++){
// for(int v=w[i];v<=V;v++){
// dp[i][v]=max(dp[i][v],dp[i][v-w[i]]+c[i]);
// }
// }
//完全背包问题
for(int i=0;i<=n;i++){
for(int v=w[i];v<=V;v++){ //正向枚举v
dp[v]=max(dp[v],dp[v-w[i]]+c[i]);
}
}
//寻找dp[0...V]中最大值
int max=0;
for(int v=0;v<=V;v++){
if(dp[v]>max)
max=dp[v];
}
printf("%d\n",max);
return 0;
}