字符串LCS,LIS问题多种解法

最长公共序列（LCS)

问题描述：

给定两个序列X<x1,x2,…,xmx1,x2,…,xm>和Y<y1,y2,…,yny1,y2,…,yn>，求X和Y的最长公共子序列。

例如：输入两个字符串 BDCABA 和 ABCBDAB，字符串 BCBA 和 BDAB 都是是它们的最长公共子序列，则输出它们的长度。
注意：子序列可以不连续。
思路：从某一个字串开始考虑，假如最后一位相等，只需要在上一情况加上1，假如最后一位不相等，则分类考虑。
递推如下：
$$dp[i+1][j+1]=\{\begin{array}{ll}dp[i][j]+1& \text{si+1=ti+1 }\\ max(dp[i+1][j],dp[i][j+1])& \text{其他情况}\end{array}$$

string a,b;
int dp[MAX_N+1][MAX_M+1]
void solve{
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(a[i]==b[j])
				dp[i+1][j+1]=dp[i][j]+1;
			else 
				dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
		}
	}
	printf("%d\n",dp[n][m]);
}

变式

一个字符串如果从左往右读和从右往左读都一样，那么这个字符串是一个回文串。例如：“abcba”，“abccba”。

蒜头君想通过添加字符把一个非回文字符串变成回文串。例如：“trit”，可以添加一个’i’ 变成回文串"tirit"。请你用程序计算出，对于一个给定的字符串，最少需要添加几个字符，才能变成回文串。

输入格式
输入一个长度为 n(1 \leq n \leq 3000)n(1≤n≤3000) 的字符串。（字符串只包含字母）

输出格式
输出最少需要添加的字符个数，占一行。

样例输入
trit
样例输出
1
思路：
求a与a的逆序字串的最大公共子序列长度，所需要补足的长度为a的长度减去最大公共长度。

代码：

#include <iostream>
#include <string>
using namespace std;
int dp[100][100];
int main() {
    string a;
    cin >> a;
    string b(a.rbegin(), a.rend());
    for (int i = 1; i <= a.length(); i++) {
        for (int j = 1; j <= b.length(); j++) {
            if (a[i - 1] == b[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 << a.length() - dp[a.length()][b.length()];
    return 0;
}

（注意b字串赋值的时候的迭代器写法！）

最长连续子串

问题描述：

给定两个序列X<x1,x2,…,xmx1,x2,…,xm>和Y<y1,y2,…,yny1,y2,…,yn>，求X和Y的最长连续子串。

例如：输入两个字符串 acbac和 acaccbabb，则最大连续子串为 “cba”, 则返回长度 3。
思路：

1. 动态规划
   定义dp[i+1][j+1]表示以a[i]和b[j]为结尾的公共子数组的最长长度（注意公共子数组一定分别包含A[i]和B[j]作为末元素，类比最大子段和问题）
   当a[i]!=b[j]时，dp[i+1][j+1]=0, 因为以a[i]和b[j]结尾的公共子数组不存在，因为它们的末元素不等。
   当a[i]==b[j]时，dp[i+1][j+1]=dp[i][j]+1, 因为a[i]和b[j]相等，以它们俩为结尾的最长公共子数组的长度就是以a[i-1]和b[j-1]结尾的最长公共子数组的长度加1。
   递归方程为：
   $$dp[i+1][j+1]=\{\begin{array}{ll}dp[i][j]+1& \text{si+1=ti+1 }\\ 0& \text{si+1!=ti+1}\end{array}$$

核心代码1：

int MAX = 0;
memset(dp,0,sizeof(dp));
for (int i = 0; i < a.length(); i++) {
     for (int j = 0; j < b.length(); j++) {
          if (a[i] == b[j])
            dp[i + 1][j + 1] = dp[i][j] + 1;
          MAX = max(MAX, dp[i + 1][j + 1]);
     }
}
cout << MAX;

核心代码2：（一维数组解法）

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    string a, b;
    cin >> a >> b;
    vector<int> dp(b.size() + 1, 0);
    int MAX = 0;
    for (int i = 0; i < a.size(); i++) {
        for (int j = b.size() - 1; j >= 0; j--) {
            dp[j + 1] = (a[i] == b[j] ? dp[j] + 1 : 0);
            MAX = max(MAX, dp[j + 1]);
        }
    }
    cout << MAX;
}

最长上升子序列(LIS)

定义$dp[i]$:以$a_i$为末尾的最长上升子序列的长度。
$a_i$为末尾的最长上升子序列的长度是：

1. 只包含$a_i$的子序列
2. 满足$j<i$且$a_j<a_i$的以$a_j$结尾的上升子列加上$a_i$

int n;
int a[MAX_N];
int dp[MAX_N];
void solve(){
	int res=0;
	for(int i=0;i<n;i++){
		dp[i]=1;
		for(int j=0;j<i;j++){
			if(a[j]<a[i])
				dp[i]=max(dp[i],dp[j]+1);
		}
		res=max(res,dp[i]);
	}
	cout<<res;
}

法二：
$dp[i]$:长度i+1的上升子序列中末尾元素的最小值

int dp[MAX_N];
void solve(){
	fill(dp,dp+n,INF);
	for(int i=0;i<n;i++){
		*lower_bound(dp,dp+n,a[i])=a[i];
	}
	cout<<lower_bound(dp,dp+n,INF)-dp;
}

变式

问题描述
蒜头君面前有一排 n 个木桩，木桩的高度分别是h1,h2,h3…hn。蒜头第一步可以跳到任意一个木桩，接下来的每一步蒜头不能往回跳只能往前跳，并且跳下一个木桩的高度 不大于 当前木桩。蒜头君希望能踩到尽量多的木桩，请你帮蒜头计算，最多能踩到多少个木桩。
输入格式
第一行输入一个整数 n 代表木桩个数。第二行输入 n 个整数h1,h2,h3…hn，分别代表 n 个木桩的高度。(1≤n≤1000,1≤hi≤100000)
输出格式
输出一个整数，代表最多能踩到的木桩个数，占一行。
样例输入
6
3 6 4 1 4 2
样例输出
4
代码：

#include <algorithm>
#include <iostream>
using namespace std;
int n, a[100];
int dp[100];

int main() {
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    reverse(a, a + n);
    fill(dp, dp + n, 1111111);
    int len = 0;
    dp[0] = a[0];
    for (int i = 0; i < n; i++) {
        if (a[i] >= dp[len]) {
            dp[++len] = a[i];
        } else
            *lower_bound(dp, dp + len, a[i]) = a[i];
    }
    cout << lower_bound(dp, dp + len, 1111111) - dp;
    return 0;
}

代码2：

#include <algorithm>
#include <iostream>
using namespace std;
int n, a[100];
int dp[100];

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