基礎概念
- 字符串：S[0..n]，S是一個字符串，長度為n。S本質上是一個字符數組，數組的每個元素都是一個字符；
- 子序列：設T為S的一個子序列，則如果T[ti]和T[tj]為T的兩個字符，ti<tj，那么T[ti]和T[tj]也都是S的字符，且對應的下標si<sj。舉個例子，S為adbfhgs，那么abfg就是S的一個子序列，abcfg就不是S的子序列；
- 子串：子串是一種特殊的子序列，它要求tj - ti = sj - si，即子串的字符要在S中連續。還是設S為adbfhgs，那么adbf是S的一個子串，abfg就不是。
- 后綴：S[0..n]，那么S[i..n] (i>=0)都是S的后綴；
- 公共子序列/串：如果R既是S的子序列/串，又是T 的子序列/串，那么R就是S和T 的公共子序列/串。
最長公共子序列
問題描述
有兩個字符串S[0...m]和T[0...n]，求S和T的所有最長公共子序列的長度。
例子
設S=adbfhgs，T=hadeubgs，那么S和T的最長公共子序列為R=adbgs，長度為5。
分析
首先考慮暴力求解。枚舉S的所有子序列，總共有2m個；然后再枚舉T的所有子序列，總共有2n個；最后一一匹配，總的時間復雜度為O(2^(m+n))。顯然是不可行的。
考慮一種動態規劃的方法。
-
狀態表####
dp[i][j]，i和j分別是S和T的下標，dp[i][j]為當前狀態下的最長公共子序列的長度。其中i和j分別從0開始遞增，即狀態表是從左往右，從上往下依次被填滿的（假設左上方的i和j都是0）。
-
基礎狀態####
dp[0][j]=0，dp[i][0]=0。顯然當一個字符串為空時，兩字符串的最長公共子序列就是空字符串，長度為0
-
狀態轉移方程####
dp[i][j]=dp[i-1][j-1]+1, S[i]=T[j];
dp[i][j]=max(dp[i-1][j],dp[i][j-1]), S[i]!=T[j].
當S[i]=T[j]時，如果i-1和j-1狀態下的最長公共子序列為R，那么i和j狀態下的最長公共子序列就為R+S[i] (T[j])，所以長度會加1；
當S[i]!=T[j]，i和j狀態下的最長公共子序列要么是i-1和j狀態下的最長公共子序列，要么是i和j-1狀態下的最長公共子序列，所以長度取這兩個最長公共子序列的長度的最大值。
打印
到目前為止，我們已經得到了一張填好的狀態表。那么怎么通過這張狀態表打印出對應的最長公共子序列呢？
從狀態表的右下方開始，向上回溯。具體算法詳見代碼。
代碼
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
string s, t;
cin >> s >> t;
int slen = s.length();
int tlen = t.length();
vector<vector<int>> dp(slen + 1, vector<int>(tlen + 1, 0));
for (int i = 1; i <= slen; i++)
for (int j = 1; j <= tlen; j++)
if (s[i - 1] == t[j - 1])
dp[i][j] = dp[i - 1][j - 1] + 1;
else
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
int lcslen = dp[slen][tlen]; // 最長公共子序列長度
string lcs; // 最長公共子序列
lcs.resize(lcslen);
// 從右下向左上遍歷狀態表
int i = slen, j = tlen, k = lcslen;
while (i > 0 && j > 0)
{
if (s[i - 1] == t[j - 1])
{
lcs[--k] = s[i - 1];
i--; j--;
}
else if (dp[i - 1][j] < dp[i][j - 1])
j--;
else
i--;
}
cout << "longest common subsequence length: " << lcslen << endl;
cout << "longest common subsequence: " << lcs << endl;
return 0;
}
最長公共子串
問題描述
有兩個字符串S[0...m]和T[0...n]，求S和T的所有最長公共子串的長度。
例子
設S=adbfhgs，T=hadeubgs，那么S和T的最長公共子串為R=ad或者gs，長度為2。
分析
首先考慮暴力求解。枚舉S的所有子串，總共有(m2+m)/2個；然后再枚舉T的所有子序列，總共有(n2+n)/2個；最后一一匹配，總的時間復雜度為O(m2*n2)，也是不可行的。可以使用KMP算法把匹配的復雜度降到O(n)，但是總的復雜度O(m^2*n)還是太高。
考慮一種動態規劃的方法。
-
狀態表####
dp[i][j]，i和j分別是S和T的下標。注意，這里的dp[i][j]并不是當前狀態下的最長公共子串的長度，而是最長公共后綴的長度。舉個例子，S為abxcdef，T為frcdef，當i=4，j=3，即i指向d，j指向也是d，則當前字符串abxcd和frcd的最長公共后綴為cd。要明確后綴就是從后往前看，依次進行匹配就行了。其中i和j分別從0開始遞增，即狀態表是從左往右，從上往下依次被填滿的（假設左上方的i和j都是0）。
-
基礎狀態####
dp[0][j]=0，dp[i][0]=0。顯然當一個字符串為空時，兩字符串的最長公共子串就是空字符串，長度為0
-
狀態轉移方程####
dp[i][j]=dp[i-1][j-1]+1, S[i]=T[j];
dp[i][j]=0, S[i]!=T[j];
lcslen=max(lcslen, dp[i][j]).
當S[i]=T[j]時，如果i-1和j-1狀態下的最長公共后綴為R，那么i和j狀態下的最長公共后綴就為R+S[i] (T[j])，所以長度會加1；設S為abxcdef，T為frcdef，i=4(指向d)，j=3(指向d)，i-1和j-1狀態下的最長公共后綴為c，i和j狀態下的最長公共后綴就是cd，長度為2；
當S[i]!=T[j]，設S為abxcdef，T為frcdef，i=4(指向d)，j=4(指向e)，則當前字符串abxcd和frcde的最長公共后綴為空，長度為0。
lcslen是最長公共子串的長度，每次更新狀態的時候更新。
打印
構建狀態表的時候，保存每次檢測到的最長公共子串的尾下標，最后從尾下標開始往前查找字符串，直到找到兩個不相同的字符為止。
代碼
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
string s, t;
cin >> s >> t;
int slen = s.length();
int tlen = t.length();
vector<vector<int>> dp(slen + 1, vector<int>(tlen + 1, 0));
int lcsi, lcsj; // 最長公共子串的尾下標
int lcslen = 0; // 最長公共子串長度
for (int i = 1; i <= slen; i++)
for (int j = 1; j <= tlen; j++)
if (s[i - 1] == t[j - 1])
{
dp[i][j] = dp[i - 1][j - 1] + 1;
if (dp[i][j] > lcslen)
{
lcslen = dp[i][j];
lcsi = i;
lcsj = j;
}
}
string lcs;// 最長公共子串
lcs.resize(lcslen);
for (int i = lcsi - 1, j = lcsj - 1, k = lcslen;
i >= 0 && j >= 0; )
{
if (s[i] == t[j])
{
lcs[--k] = s[i];
i--; j--;
}
else
break;
}
cout << "longest common substring length: " << lcslen << endl;
cout << "longest common substring: " << lcs << endl;
return 0;
}
