PS: 做题时一直对几个经常常见的求最长字符串啥的混淆，例如最长回文子串，最长回文子序列，最长公共子串，最长公共子序列，无重复最长子串。。。。。。，故记录一波。
注意：
a. 子串与子序列区别在于子串是连续的，子序列可以不连续。
b. 下面的代码侧重于用 动态规划（DP）解决，同时对特定题目也会列出其他解法。
-------------------------------------------------------我是帅气的分割线^^ -----------------------------------------------
1.最长回文子串
// 最长回文子串 (O(N^2) + O(N)) , // 中心扩展法
class Solution {
public:
string longestPalindrome(string s) {
string res;
for (int i = 0; i < s.size(); i++) {
// 以s[i] 为中心的最长回文字符串
string s1 = ispalindrome(s, i, i);
// 以s[i] 和 s[i+1] 为中心的最长回文字符串
string s2 = ispalindrome(s, i, i + 1);
res = res.size() > s1.size() ? res : s1;
res = res.size() > s2.size() ? res : s2;
}
return res;
}
string ispalindrome(string& s, int left, int right) {
// 防止越界
while (left >= 0 && right < s.size() && s[left] == s[right]) {
left--; // 向两边展开
right++;
}
// 返回以 s[left] 和 s[right] 为中心的最长回文串
return s.substr(left + 1, right - left - 1);
}
};
// 最长回文子串 (O(N^2) + O(N)) , // 动态规划法
//我们将f[i][j]表述为从j到i的子串为回文串，j <= i，
//此时dp的矩阵为左下三角！如果a[i]==a[j]且f[i-1][j+1]=true, 那么f[i][j]也为true。
//需要注意一点：当i - j < 2时，如果s[i] = s[j]，
//那么f[i][j]必为true，即单个字符或者两个相邻相同字符为回文子串。
class Solution11 {
public:
string LongPalindromeSubstr(string s) {
int n = s.length();
if (n == 0) return "";
string res = "";
vector<vector<bool>> dp(n, vector<bool>(n, false));
int maxlen = 0;
int curlen = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) { // dp[0][0]=true, 一定成立
if ((s[i] == s[j]) && ((i - j < 2) || (i > 0 && dp[i - 1][j + 1]))) {
dp[i][j] = true;
curlen = i - j + 1;
if (curlen > maxlen) {
maxlen = curlen;
res = s.substr(j, curlen);
}
}
}
}
return res;
}
};
2.最长回文子序列
// 最长回文子序列 动态规划dp
class Solution2 {
public:
int LongestpalindromeSubSequence(string s) {
if (s.size() == 0) return 0;
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n, 0)); // dp[i][j]表示字符串 s[j:i] 的最长回文子序列长度
//base case
for (int i = 0; i < s.size(); i++) {
dp[i][i] = 1;
}
// 状态转移
for (int i = n - 1; i >= 0; i++) {
for (int j = i + 1; j < n; j++) {
if (s[i] == s[j]) {
dp[i][j] = dp[i + 1][j - 1] + 2;
}
else {
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
return dp[0][n - 1]; // 最长回文子串长度
}
};
3.最长公共子串
// 最长公共子串,
class Solution3 {
public:
int LongestCommonSubstr(string str1, string str2) {
if (str1.size() == 0 && str2.size() != 0) return 0;
if (str1.size() != 0 && str2.size() == 0) return 0;
int n = str1.size();
int m = str2.size();
int res = 0;
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0)); // dp[i][j] 表示 str1[:i] 和 str2[:j] 的公共子串长度
for (int i = 0; i <= n; i++) { // base case
dp[i][0] = 0;
}
for (int j = 0; j <= m; j++) {
dp[0][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (str1[i - 1] == str2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
res = max(dp[i][j], res); // 更新最大值
}
else { // 不相等的情况
dp[i][j] = 0;
}
}
}
return res;
}
};
4.最长公共子序列
// 最长公共子序列
class Solution4 {
public:
int LongCommonSubSequence(string str1, string str2) {
int n = str1.size();
int m = str2.size();
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0)); // dp[i][j] 代表 str1[0:i] 和 str2[0:j] 的公共子序列长度
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (str1[i] == str2[j]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[n][m];
}
};
5.最长回文串（hashmap 统计字符个数）
class Solution5 {
public:
int longestPalindrome(string s) {
if (s.size() == 0) return 0;
map<char, int> hashmap;
for (auto str : s) {
hashmap[str]++;
}
int count = 0;
for (auto it = hashmap.begin(); it != hashmap.end(); it++) {
if (it->second%2 == 0) {
count += it->second;
}
else {
count += it->second - 1; // 如果有奇数个的，就变成偶数个的
}
}
if (count < s.size()) { // 如果不是全部都是偶数个的， 则结果中只能有一个奇数个
count += 1;
}
return count;
}
};
6.无重复最长子串
// 无重复最长子串 hashmap 边遍历变存储
class Solution6 {
public:
int LongestNoRepeatSubstr(string str) {
if (str.size() == 0) return 0;
unordered_map<char, int> hashmap; // hashmap 记录的 字符出现的 index
int max_length = 0;
int left =g 0;
for (int i = 0; i < str.size(); i++) {
if (hashmap.find(str[i]) != hashmap.end()) {
left = max(left, hashmap[str[i]] + 1); //出现重复后 更新左边界
}
max_length = max(max_length, i - left + 1);
hashmap[str[i]] = i;
}
return max_length;
}
};
// 使用滑动窗口方法
int lengthOfLongestSubstring(string s) {
unordered_map<char, int> window;
int left = 0, right = 0;
int res = 0; // 记录结果
while (right < s.size()) {
char c = s[right];
right++;
// 进行窗口内数据的一系列更新
window[c]++;
// 判断左侧窗口是否要收缩
while (window[c] > 1) {
char d = s[left];
left++;
// 进行窗口内数据的一系列更新
window[d]--;
}
// 在这里更新答案
res = max(res, right - left);
}
return res;
}
7.最长上升子序列
// 最长上升子序列 , 动态规划 O(n^2)
class Solution7 {
public:
int LongestUpSubstr(vector<int> str) {
if (str.size() == 0) return 0;
int n = str.size();
// dp[i] 代表dp[i] 表⽰以 str[i] 这个数结尾的最⻓递增⼦序列的⻓度
vector<int> dp(n, 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (str[i] > str[j]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
}
int res = dp[0];
for (int i = 1; i < n; i++) {
res = max(res, dp[i]);
}
return res;
}
};
这里再提供一个来自大神的优化版本，使用二分法优化
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int lengthOfLIS(vector<int> &nums) {
int len = nums.size();
if (len < 2) {
return len;
}
vector<int> tail; // tail 数组的定义：长度为 i + 1 的上升子序列的末尾最小是几
tail.push_back(nums[0]);// 遍历第 1 个数，直接放在有序数组 tail 的开头
// tail 结尾的那个索引
int end = 0;
for (int i = 1; i < len; ++i) {
if (nums[i] > tail[end]) { //逻辑1：比 tail 数组实际有效的末尾的那个元素还大
tail.push_back(nums[i]); // 直接添加在那个元素的后面，所以 end 先加 1
end++;
} else {
// 使用二分查找法，在有序数组 tail 中
// 找到第 1 个大于等于 nums[i] 的元素，尝试让那个元素更小
int left = 0;
int right = end;
while (left < right) {
// 选左中位数不是偶然，而是有原因的，原因请见 LeetCode 第 35 题题解
// int mid = left + (right - left) / 2;
int mid = (left + right) >> 1; // 右移一位等于 除2了
if (tail[mid] < nums[i]) {
// 中位数肯定不是要找的数，把它写在分支的前面
left = mid + 1;
} else {
right = mid;
}
}
// 走到这里是因为 【逻辑 1】 的反面，因此一定能找到第 1 个大于等于 nums[i] 的元素
// 因此，无需再单独判断
tail[left] = nums[i];
}
}
// 此时 end 是有序数组 tail 最后一个元素的索引
// 题目要求返回的是长度，因此 +1 后返回
return end + 1;
}
};
作者：liweiwei1419
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
