动态规划常见模型

ps:动态规划经常考虑倒着来做

（1）最大子段和(子段：指一段连续的子数列）

eg:

6（数据个数）

-2 11 -4 13 -5  -2

解法一：暴力枚举两个端点，时间复杂度o(n)

解法二：

#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
int a[1000]={0};
int max=-99;
for(int i=1;i<=n;i++){
	cin>>a[i];

	if(a[i]>max)max=a[i];

}

int sum=0;
for(int i=1;i<=n;i++){
	sum+=a[i];
	if(sum<=0)sum=0;
	else{
		if(sum>max)max=sum;
	}
}

cout<<max<<endl;
} 

(2)最长上升子序列

最长上升子序列，又称LIS(Longest Increasing Subsequence)是动态规划的一个经典应用。

在原序列取任意多项（不要求连续—）,不改变他们在原来数列的先后次序，得到的序列称为#原序列的子序列。最长上升子序列，就是给定序列的一个最长的、数值从低到高排列的子序列,最长上升子序列不一定是唯一的。例如，序列2,1,5,3,6,4,6,3的最长上升子序列为1,3,4,6和2,3,4,6，长度均为4。

输入：

8
2 1 5 3 6 4 6 3

输出：4

#include<iostream>
using namespace std;
int n;
int a[1000]={0};
int times[1000]={0};
int LIS(){
	int ans=0;//remember the times 
	for(int i=1;i<=n;i++){
		times[i]=1;
		for(int j=i-1;j>=1;j--){
		if(a[j]<a[i]){
			times[i]=max(times[i],times[j]+1);
		}
		}
		if(times[i]>ans)ans=times[i];
	}
	return ans;
}
int main(){
	
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	int a=LIS();
	cout<<a<<endl;
}

（3）最长公共子序列

最长公共子序列:给定两个序列S和S2，求二者公共子序列S的最长的长度有了前面的基础，可以发现这个问题仍然可以按照序列的长度来划分状态，也就是 S 的前个字符和 S的前个字符的最长公共子序列长度，记为 lcs[][。如果Si的第项，和S2的第项相同，那么 S与S[作为公共子序列的末尾，则(即当S的第i个和S2的第j个能匹配时：）
LCS[i][j]  =    LCS[i-1] [j-1]  +  1 

也可以不让Si与S2作为公共子序列的末尾（当S的第i个和S2的第j个不能匹配时，判断：i-1和j以及i和j-1能否匹配），则
LCS[i][j] = max(   LCS[i-1[[j-1]]   ,   LCS[i-1[[j]   )

ps:如果当前i,j相等，则dp[i+1][j+1]的值加一

 

#include<iostream>
#include<algorithm>
#include<bits/stdc++.h>
using namespace std;
//本题中求的最长公共子序列，不是连续的 
int main(){
	string s1,s2;
	cin>>s1>>s2;
	int len1=s1.size();
int dp[100][100]={0};
int len2=s2.size()	;
cout<<"len:"<<len1<<endl;
for(int i=1;i<=len1;i++){
		for(int j=1;j<=len2;j++){
			if(s1[i-1]==s2[j-1]){//两个相等的话，直接都向前一位继续判断 
				dp[i][j]=dp[i-1][j-1]+1;
				
			}
			else {//如果当前不相等，让两个字符串分别向前移动一位，计算最大的作为当前值 
			dp[i][j]=max(dp[i-1][j],dp[i][j-1]); 
				
			}
		}
	}
	cout<<dp[len1][len2]<<endl; 
	return 0;
} 

(四)两个字符串S=“ABCF”(m个字符），T=“DBFG"（n个字符）,之间的操作,找到至少的步骤，将T转化为S 

（1）删除其中一个的任意一个字符

（2）将其中一个字符改为另外一个字符

（3）加入任意一个字符

一：直接将T删除，转化为S，需m+n次

二：不能用搜索，因为需要逐个考虑将字符添加删除，时间复杂度：O(26^m)

三：思路：添加—，使得两个字符串长度相同，考虑字符串的位置，使得已有的字符有最多的对齐，在进行不相同字符串的修改