最长XX子串/数组/子序列

一、最长公共子串

　　题目描述：

　　　　字符串s=“heqlloled”，字符串p=“eolold!”。找出两个字符串最长的共有的子字符串。　

　　输入：
　　　　acbcbcef
　　　　abcbced
　　输出：
　　　　5
　　　　bcbce

　　解决：
　　　　dp[i][j]表示s[0,…i]与p[0,…j]区间之间而且以i和j结尾的最长公共子串长度，状态转移方程：

　　　　　　(1)当s[i]==p[j]时，dp[i][j]=dp[i-1][j-1]+1;
　　　　　　(2)当s[i]!=p[j]时，dp[i][j]=0;

　　代码如下：

string LongestCommonSubstring(string s, string p)
{
    int slen = s.size(), plen = p.size();
    vector<vector<int> > dp(slen + 1, vector<int>(plen + 1, 0));

    //anslen代表公共子串的长度，endpos代表公共子串的结束位置
    int anslen = 0, endpos = -1;
    for (int i = 1; i <= slen; i++)
    {
        for (int j = 1; j <= plen; j++)
        {
            if (s[i - 1] == p[j - 1])
            {
                dp[i][j] = dp[i - 1][j - 1] + 1;
                if (dp[i][j] > anslen)
                {
                    anslen = dp[i][j];
                    endpos = i - 1;
                }
            }
            else    //两个字符不相等的时候，说明以s[i-1]和p[j-1]结尾的公共子串长度为0
            {
                dp[i][j] = 0;
            }
        }
    }

    //获取公共子串
    string ansstr = s.substr(endpos - anslen + 1, anslen);
    return ansstr;
}

 

二、最长公共子序列

　　题目描述：

　　　　字符串s=“heqlloled”，字符串p=“eolold!”。输出最长公共子序列。

　　输入：
　　　　abcde
　　　　ace
　　输出：
　　　　3
　　　　ace

　　解决：
　　　　dp[i][j]表示s[0,…i]与p[0,…j]的最长公共子序列长度。

　　状态转移方程：

　　　　(1) 当s[i]==p[j]时，dp[i][j] = dp[i-1][j-1] + 1;
　　　　(2) 当s[i]!=p[j]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1]);

　　代码如下：

string longestCommonSubsequence(string s, string p)
{
    int slen = s.size(), plen = p.size();
    vector<vector<int> > dp(slen + 1, vector<int>(plen + 1, 0));


    for (int i = 1; i <= slen; i++)
    {
        for (int j = 1; j <= plen; j++)
        {
            if (s[i - 1] == p[j - 1])
            {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            }
            else    //两个字符不相等的时候，说明以s[i-1]和p[j-1]结尾的公共子串长度为0
            {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }

    int index1 = slen, index2 = plen;
    string ans;
    while (index1 > 0 && index2 > 0)
    {
        if (s[index1 - 1] == p[index2 - 1])
        {
            ans.push_back(s[index1 - 1]);
            index1--;
        }
        else
        {
            if (dp[index1][index2 - 1] > dp[index1 - 1][index2])
                index2--;// 说明相同的字符在行这边，下次遍历的时候应该是同一行，列向前退一格，所以index2--
            else
                index1--;
        }
    }
    
    reverse(ans.begin(), ans.end());
    return ans;
}

三、寻找目标子串

　　题目链接：https://leetcode-cn.com/problems/implement-strstr/

　　在一个字符串中寻找是否包含目标字符串，实现这个要求并不难，遍历文本的每个字符串，如果和目标字符串的第一个匹配，就把匹配的字符后移一位继续对比，直到不匹配，然后将文本的指针后移一位，继续对比即可。但是这样的暴力匹配最坏情况的时间复杂度为O（n*m），而KMP算法可以将其复杂度降低到O（n+m），减少重复对比次数。

　　代码如下：

void getNext(string str, vector<int> & next)
{
    //这里必须是减1
    int len = str.size() - 1;
    int i = 0, k = -1;
    next[0] = -1;
    while (i < len && k < len)
    {
        if (k == -1 || str[i] == str[k])
        {
            i++;
            k++;
            next[i] = k;

            /*
            i++;
            k++;
            if (str[i] == str[k])
                next[i] = next[k];
            else
                next[i] = k;
            */
        }
        else
        {
            k = next[k];
        }
    }
}


int strStr(string source, string target)
{
    int slen = source.size(), tlen = target.size();

    //特殊情况处理
    if (tlen == 0)
        return 0;

    if (slen == 0)
        return -1;

    //获取next数组
    vector<int> next(tlen, 0);
    getNext(target, next);
    int i = 0, j = 0;
    while (i < slen && j < tlen)
    {
        if (j == -1 || source[i] == target[j])
        {
            i++;
            j++;
        }
        else
        {
            j = next[j];
        }
    }
    if (j >= tlen)
    {
        return i - tlen;    //返回起始位置
    }
    else
    {
        return -1;    //不存在
    }
}

四、最长回文子串

　　题目链接：https://leetcode-cn.com/problems/longest-palindromic-substring/

　　题目描述：给你一个字符串 s，找到 s 中最长的回文子串。

　　解法1：动态规划：对于一个子串而言，如果它是回文串，并且长度大于 22，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 \textrm{``ababa''}“ababa”，如果我们已经知道 \textrm{``bab''}“bab” 是回文串，那么 \textrm{``ababa''}“ababa” 一定是回文串，这是因为它的首尾两个字母都是 \textrm{``a''}“a”。

　　dp[i][j]代表从i到j的子串是否为回文串，如果s[i] == s[j] 并且j - i == 1或者dp[i+1][j-1]为true，那么dp[i][j] = true;时间复杂度和空间复杂度分别为O(n^2)和O(n^2)。

　　代码如下：

string longestPalindrome(string s)
{
    int len = s.size();
    vector<vector<bool> > dp(len, vector<bool>(len, false));
    //初始化
    for (int i = 0; i < len; i++)
        dp[i][i] = true;

    //结果标记
    int anslen = 0, beginpos = 0, endpos = 0;

    for (int i = len - 2; i >= 0; i--)
    {
        for (int j = i + 1; j < len; j++)
        {
            if (s[i] == s[j] && (j - i == 1 || dp[i + 1][j - 1]))
            {
                dp[i][j] = true;
                if (j - i + 1 > anslen)
                {
                    anslen = j - i + 1;
                    endpos = j;
                    beginpos = i;
                }
            }
        }
    }

    string ansstr = s.substr(beginpos, endpos - beginpos + 1);

    return ansstr;
}

 

　　解法2：中心扩展算法：我们枚举所有的「回文中心」并尝试「扩展」，直到无法扩展为止，此时的回文串长度即为此「回文中心」下的最长回文串长度。我们对所有的长度求出最大值，即可得到最终的答案。

　　代码如下：

int helper(string s, int left, int right)
{
    while (left >= 0 && right < s.size() && s[left] == s[right])
    {
        left--;
        right++;
    }

    return right - left - 1;
}



string longestPalindrome(string s)
{
    int len = s.size();
    
    int beginpos = 0, endpos = 0, anslen = 0;
    for (int i = 0; i < len; i++)
    {
        int odd_len = helper(s, i, i);
        int even_len = helper(s, i, i + 1);
        int tlen = max(odd_len, even_len);
        if (tlen > anslen)
        {
            anslen = tlen;
            beginpos = i - (tlen - 1) / 2;
            endpos = i + tlen / 2;
        }
    }

    string ansstr = s.substr(beginpos, anslen);
    return ansstr;
}

五、最长重复子串

　　题目链接：

　　　　https://leetcode-cn.com/problems/longest-duplicate-substring/　

　　题目描述：

　　　　给出一个字符串 S，考虑其所有重复子串（S 的连续子串，出现两次或多次，可能会有重叠）。

　　　　返回任何具有最长可能长度的重复子串。（如果 S 不含重复子串，那么答案为 ""。）

　　解决：二分+字符串哈希　　

　　代码如下：

const int maxlen = 100000 + 50;
typedef unsigned long long ULL;
int base = 13331;
int f[maxlen], h[maxlen];

ULL getKey(int l, int r)
{
    return l == 0 ? h[r] : h[r] - h[l - 1] * f[r - l + 1;
}


string Check(int mid, string & s)
{
    unordered_map<ULL, bool> mp;
    int len = s.size();
    string cur;
    for (int i = 0; i < len; i++)
    {
        if (i + mid - 1 < len)
        {
            ULL key = getKey(i, i + mid - 1);
            if (mp.count(key))
            {
                cur = s.substr(i, mid);
                break;
            }
            mp[key] = true;
        }
    }
    return cur;
}


string longestDupSubstring(string s)
{
    int len = s.size();

    //预处理哈希值
    f[0] = 1;
    for (int i = 0; i < len; i++)
    {
        if (i == 0)
            h[i] = s[i];
        else
        {
            h[i] = h[i - 1] * base + s[i];
            f[i] = f[i - 1] * base;
        }
    }

    string ans;
    int left = 0, right = len - 1;
    while (left < right)
    {
        int mid = (left + right + 1) / 2;
        string cur = Check(mid, s);
        if (cur.size() > ans.size())
        {
            ans = cur;
            left = mid;
        }
        else
        {
            right = mid - 1;
        }
    }

    return ans;
}

六、最长不含重复字符的子串

　　题目链接：

　　　　https://leetcode-cn.com/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/

　　题目描述：

　　　　请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

　　解决：双指针+滑动窗口

　　代码如下：

int lengthOfLongestSubstring(string s)
{
    int len = s.size();
    if (!len)
        return 0;
    int left = 0, right = 0, ans = 0;
    unordered_map<char, int> mp;
    while (right < len)
    {
        char ch = s[right];
        mp[ch]++;
        while (mp[ch] > 1)
        {
            mp[s[left]]--;
            left++;
        }
        ans = max(ans, right - left + 1);
        right++;
    }
    return ans;
}

七、最长递增子序列

　　题目链接：

　　　　https://leetcode-cn.com/problems/longest-increasing-subsequence/

　　题目描述：　　

　　　　给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

　　　　子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

　　解决：动态规划

　　代码如下：

int lengthOfLIS(vector<int>& nums) {
    int len = nums.size();
    vector<int> dp(len + 1, 1);
    dp[0] = 0;
    int maxlen = 0;
    for (int i = 1; i <= len; i++) {
        for (int j = 1; j < i; j++) {
            if (nums[i - 1] > nums[j - 1])
                dp[i] = max(dp[i], dp[j] + 1);
        }
        maxlen = max(maxlen, dp[i]);
    }

    //输出子序列
    int sublen = maxlen;
    vector<int> sublis(sublen, 0);
    int index = len;
    for (; index > 0; index--)
    {
        if (dp[index] == sublen)
            break;
    }
    sublis[--sublen] = nums[index - 1];
    for (int i = index - 1; i > 0; i--)
    {
        if (nums[i - 1] < nums[index - 1] && dp[i] == dp[index] - 1)
        {
            sublis[--sublen] = nums[i - 1];
            index = i;
        }
    }

    for (int i = 0; i < maxlen; i++)
        cout << sublis[i] << " ";

    return maxlen;
}

八、参考文章

https://blog.csdn.net/s448312891/article/details/80318746