动态规划三（最大连续子序列和、最长不下降子序列、最长公共子序列、最长回文子串）

最大连续子序列和

问题：
  给定一个数字序列A₁,A₂,…,A_n，求i,j（1<=i<=j<=n），使得Ai+····+Aj最大，输出这个最大和。

步骤：

1. 令状态dp[i]表示以A[i]作为末尾的连续序列的最大和。
   通过设置这么一个dp数组，要求的最大和其实就是dp[0],dp[1],···,dp[n-1]中的最大值。
2. 因为dp[i]要求的是以A[i]结尾的连续序列，那么只有两种情况：
   ①这个最大和的连续序列只有一个元素，即以A[i]开始，以A[i]结尾。
   ②这个对大河的连续序列有多个元素，即从前面某处A[p]开始(p 对第一种情况，最大和就是A[i]本身。
   对第二种情况，最大和是dp[i-1]+A[i]，即A[p]+····+A[i-1]+A[i]。
   由于只有两种情况，于是得到状态转移方程：
      dp[i] = max(A[i] , dp[i-1]+A[i])
   这个式子之和i与i之前的元素有关，且边界为dp[0] = A[0]，因此从小到大枚举i，即可得到整个dp数组，接着输出dp[0],dp[1],····,dp[n-1]中的最大值即为最大连续子序列的和。

#include
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 =1;i<n;i++){
		//状态转移方程
		dp[i] = max(dp[i-1]+A[i],A[i]); 
	} 
	//遍历得到最大的dp[i]
	int k = 0;
	for(int i =0;i<n;i++){
		if(dp[i]>dp[k]){
			k = i;
		}
	} 
	printf("%d\n",dp[k]);
	return 0;
} 

最长不下降子序列(LIS)

问题：
  在一个数字序列中，找到一个最长的子序列（可以不连续），使得这个子序列是不下降（非递减）的。

步骤：
  令dp[i]表示以A[i]结尾的最长不下降子序列长度。这样对A[i]来说有两种可能：

1. 如果存在A[i]之前的元素A[j]，使得A[j]<=A[i]且dp[j] +1>dp[i]（即把A[i]跟在以A[j]结尾的LIS后面是能比当前以A[i]结尾的LIS长度更长），那么就把A[i]跟在以A[j]结尾的LIS后面，形成一条更长的不下降子序列。（令dp[i] = dp[j]+1）
2. 如果A[i]之前的元素都比A[i]大，那么A[i]只能自己形成一条LIS，但是长度为1。
   最后以A[i]结尾的LIS长度就是1,2中能形成的最大长度。
   因此可以写出状态转移方程：
    dp[i] = max{1,dp[j]+1} （j = 1,2,3····i-1 && A[j] <= A[i]）
   边界为：dp[i] = 1(1<=i<=n)。

  只要让i从小到大遍历即可求出整个dp数组，之后求出整个dp数组中的最大值即是整个序列的LIS长度。

#include
using namespace std;
const int N = 100;
int A[N],dp[N];
int main(){
	int n ;
	scanf("%d",&n);
	for(int i =0;i<n;i++){
		scanf("%d",&A[i]);
	}
	int ans = -1;//记录最大的dp[i]
	for(int i =0;i<n;i++){
		dp[i] = 1;//初始化，只包含自己的LIS
		for(int j = 0;j<n;j++){
			if(A[j]< = A[i] && (dp[j]+1>dp[i])){
				dp[i] = dp[j]+1;//状态转移方程 
			}
		}
		if(dp[i] > ans){
			ans = dp[i];
		} 
	} 
	printf("%d\n",ans);
	return 0;
} 

最长公共子序列(LCS)

问题：
  给定两个字符串（或数字序列）A和B，求一个字符串，使得这个字符串是A和B的最长公共部分（子序列可以不连续）。

  令dp[i][j]表示A中i号位和B中j号位之前的LCS长度，那么可以根据A[i]和B[j]的情况，分为两种决策：

1. 若A[i] == B[j]，则字符串A与字符串B的LCS增加1位，即有dp[i][j] = dp[i-1][j-1]+1。
2. 若A[i] != B[j]，则字符串A的i号位和字符串B的j号位之前的LCS无法延长，因此dp[i][j]会继承dp[i-1][j]和dp[i][j-1]中的较大值，即有dp[i][j] = max{ dp[i-1][j] , dp[i][j-1] }。
   由此得到状态转移方程：
     dp[i][j] = if(A[i] == B[j]) dp[i-1][j-1]+1,
         if(A[i] != B[j]) max(dp[i-1][j],dp[i][j-1])
   边界：dp[i][0] = dp[0][j] = 0 (0<=i<=n,0<=j<=m)
   这样，dp数组就只与之前的状态有关，由边界出发就可以得到整个dp数组，最终的dp[n][m]就是需要的答案。

#include
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 =0;i<lenA;i++){
		for(int j =0;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; 
} 

最长回文子串

问题：
  给出一个字符串S，求S的最长回文子串的长度。
举例：
字符串“PATZJUJZTACCBCC”的最长回文子串为“ATZJUJZTA”,长度为9
步骤：
  令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串，是则为1，不是则为0。这样根据S[i]是否等于S[j]，可以把转移情况分为两类：

1. 若S[i] == S[j]，那么只要S[i+1] 至S[j-1]是回文子串，S[i]至S[j]就是回文子串；如果S[i+1] 至S[j-1]不是回文子串，S[i]至S[j]也不是回文子串。
2. 若S[i] != S[j]，，那么S[i]至S[j]一定不是回文子串。
   由此写出状态转移方程：
         dp[i][j] = if(S[i] == S[j]) dp[i+1][j-1];
             if(S[i]!=S[j]) 0;
   边界：dp[i][i] = 1,dp[i][i+1] = (S[i] == S[i+1] ) ? 1: 0

  由于如果按照i和j从小到大的顺序来枚举子串的两个端点，然后更新dp[i][j]，会无法保证dp[i+1][j-1]已经被计算过，从而无法得到正确的dp[i][j]。
  注意到边界是长度为1和2的子串，且每次转移时都对子串的长度-1，因此不妨考虑到子串的长度和初始位置进行枚举。

#include
using namespace std;
const int maxn = 1010;
char S[maxn];
int dp[maxn][maxn];

int main(){
	gets(S);
	int len = strlen(S),ans = -1;
	memset(dp,0,sizeof(dp));//初始化dp为0
	//边界
	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;
}