76、最长公共... 和最长递增... 类型的算法题汇总

最新推荐文章于 2024-01-10 07:00:00 发布

C.&H.

最新推荐文章于 2024-01-10 07:00:00 发布

阅读量222

点赞数

分类专栏：名企高频面试算法题--TOP200（JS实现）文章标签：动态规划

本文链接：https://blog.csdn.net/sunnnnh/article/details/120588910

版权

名企高频面试算法题--TOP200（JS实现）专栏收录该内容

92 篇文章 8 订阅

订阅专栏

一、最长公共子序列（不连续）---动态规划

1.1 最长公共子序列和最长公共子串的区别

1.2 求最长公共子序列(LCS)的思路：动态规划

四*、最长递增子序列（不连续）---- 贪心+二分法

一、最长公共子序列（不连续）---动态规划

最长公共子序列-II_牛客题霸_牛客网

给定两个字符串str1和str2，输出两个字符串的最长公共子序列。如果最长公共子序列为空，则返回"-1"。目前给出的数据，仅仅会存在一个最长的公共子序列

1.1 最长公共子序列和最长公共子串的区别

子序列：即一个给定的序列的子序列，就是将给定序列中零个或多个元素去掉之后得到的结果。
子串：给定串中任意个连续的字符组成的子序列称为该串的子串。

给一个图再解释一下：

子序列： {a,b,c,d,e,f,g,h}，它的子序列示例： {a,c,e,f} 即元素b,d,g,h被去掉后，保持原有的元素序列所得到的结果就是子序列。同理，{a,h},{c,d,e}等都是它的子序列。
子串：{c,d,e,f} 即连续元素c,d,e,f组成的串是给定序列的子串。同理，{a,b,c,d},{g,h}等都是它的子串。

1.2 求最长公共子序列(LCS)的思路：动态规划

（1）递归公式：进行动态规划，构造LCS数组

c[i,j]表示Xi 和 Yj 的LCS的长度;
其中X = {x1 ... xm}，Y ={y1...yn}，Xi = {x1 ... xi}，Yj={y1... yj};

若Xi和Yj的最后一个元素相等，那么Xi和Yj的LCS就等于 {Xi减去最后一个元素} 与 {Yj减去最后一个元素} 的 LCS 再加上 S1和S2相等的最后一个元素。即C[i-1][j-1]+1;
若Xi的最后一个元素与Yj的最后一个元素不等，那么Xi和Yj的LCS就等于： {Xi减去最后一个元素} 与 Yj的LCS， {Yj减去最后一个元素} 与 Xi 的LCS 中的最大的那个序列。即max{C[i,j-1], C[i-1][j]}

（2）根据LCS数组反推，构造最长公共子序列

以的s1={1,3,4,5,6,7,7,8},s2={3,5,7,4,8,6,7,8,2} 的LCS数组为例:

注意：本文S1和S2的最LCS并不是只有1个，本文并不是着重讲输出两个序列的所有LCS，只是介绍如何通过上表，输出其中一个LCS。

2.1）第一种结果：

我们将从最后一个元素c[8][9]倒推出S1和S2的LCS：

c[8][9] = 5，且S1[8] != S2[9]，所以倒推回去，c[8][9]的值来源于c[8][8]的值(因为c[8][8] > c[7][9])。
c[8][8] = 5, 且S1[8] = S2[8], 所以倒推回去，c[8][8]的值来源于 c[7][7]。
以此类推，如果遇到S1[i] != S2[j] ，且c[i-1][j] = c[i][j-1] 这种存在分支的情况，这里请都选择一个方向（之后遇到这样的情况，也选择相同的方向）。

第一种结果为：

这就是倒推回去的路径，棕色方格为相等元素，即LCS = {3,4,6,7,8}

2.2）第二种结果：

如果遇到S1[i] != S2[j] ，且c[i-1][j] = c[i][j-1] 这种存在分支的情况，选择另一个方向，会得到另一个结果，即LCS ={3,5,7,7,8}。

1.3 实现

function LCS( s1 ,  s2 ) {
    let l1 = s1.length;
    let l2 = s2.length;
    if(l1<=0 || l2<=0){
        return -1;
    }
    let dp = [];
    for(let i=0;i<=l1;i++){
        dp[i] = []
        for(let j=0;j<=l2;j++){
            dp[i][j] = 0;
        }
    }
    for(let i=1;i<=l1;i++){
        for(let j=1;j<=l2;j++){
            if(s1[i-1]===s2[j-1]){
                dp[i][j] = dp[i-1][j-1]+1;
            }else{
                dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1])
            }
        }
    }
    
    //根据dp反推LCS，从后向前推
    let res = [];
    let m = l1,n = l2;
    while(m>0 && n>0){
        if(s1[m-1]===s2[n-1]){
            res.unshift(s1[m-1]);
            m--;
            n--;
        }else{
            if(dp[m-1][n]>dp[m][n-1]){
                m--;
            }else{
                n--;
            }
        }
    }
    if(res.length<=0){
        return -1;
    }else{
        return res.join("");
    }
}
module.exports = {
    LCS : LCS
};

二、最长公共子串（连续）--- 滑动窗口

最长公共子串_牛客题霸_牛客网

2.1 思路

使用滑动窗口的思想

2.2 实现方法一：滑动窗口

/**
 * longest common substring
 * @param str1 string字符串 the string
 * @param str2 string字符串 the string
 * @return string字符串
 */
function LCS( str1 ,  str2 ) {
    //寻找较短字符串的子串，看其是否是较长字符串的子串
    //1. str1中存放较短的字符串
    if(str1.length > str2.length){
        [str1, str2] = [str2, str1];
    }
    let len = str1.length;
    let maxlen = 0; //依次对最大长度递增 。最大长度为maxlen+1
    let res = ''; //最长的公共子串
    //2. 寻找较短字符串的子串。只需要寻找比上一个公共子串 长的 子串
    for(let i=0; i<len; i++){
        // 当前子串. 长度为maxlen+1的子串
        let tempstr = str1.slice(i-maxlen, i+1);
        if(str2.indexOf(tempstr) != -1){ //str2中存在该子串
            res = tempstr;
            maxlen++; //继续寻找最大长度为maxlen+1的子串
        }
    }
    return res;
}
module.exports = {
    LCS : LCS
};

2.3 实现方法二：动态规划（复杂度高）

一看到两个字符串的“最值”问题，一般想到二维dp。很自然地想到把str1前i个字符和str2前j个字符最长公共子串的长度作为dp[i][j]，但由于子串定义必须是原字符串连续的序列，这样定义无法找到递推关系，因此需要加限定条件——以str1[i-1]和str2[j-1]结尾的最长公共子串长度。（当前的最长公共子串的结尾是str1[i-1]和str2[j-1] ），用maxlen记录当前最长公共子串的长度。

/**
 * longest common substring
 * @param str1 string字符串 the string
 * @param str2 string字符串 the string
 * @return string字符串
 */
function LCS( str1 ,  str2 ) {
    //1. 其中有一个是空串
    if(str1 == null || str2 == null){
        return "";
    }
    //2.动态规划
    let l1 = str1.length;
    let l2 = str2.length;
    let dp = new Array(l1);
    let maxlen = 0;
    let index = 0;
    for(let i=0; i<l1; i++){
        dp[i] = new Array(l2);
    }
    //初始化。如果不赋初值为0，相加时，会直接变为NaN
    for(let i=0; i<l1; i++){
        for(let j=0; j<l2; j++){
            dp[i][j] = 0;
        }
    }
    for(let i=0;i<l1;i++){
        for(let j=0;j<l2;j++){
            if(str1[i] == str2[j]){
                if(i==0 || j==0){
                    dp[i][j] = 1;
                }else{
                    dp[i][j] = dp[i-1][j-1]+1;
                }
                if(maxlen < dp[i][j]){
                    maxlen = dp[i][j];
                    index = i;
                }
            }//if
        }//for
    }//for
    if(maxlen == 0) return "";
    return str1.slice(index-maxlen+1, index+1);
    
}
module.exports = {
    LCS : LCS
};

三、最长公共前缀（连续）

最长公共前缀_牛客题霸_牛客网

3.1 描述

给你一个长度为 n 的字符串数组 strs , 编写一个函数来查找字符串数组中的最长公共前缀，返回这个公共前缀。

3.2 思路：

对字符串数组进行排序;
然后只要比较首尾两个字符串;
找出首尾两个字符的最长公共前缀即可；

3.3 实现：

/**
  * 
  * @param strs string字符串一维数组 
  * @return string字符串
  */
function longestCommonPrefix( strs ) {
    if(!strs.length) return ""
    if(strs.length === 1) return strs[0]
    strs.sort();
    let start = strs[0]; //最小的字符串
    let end = strs[strs.length-1]; //最大的字符串
    
    //只需寻找start和end的最长公共前缀
    let res = "";
    for(let i=0; i<start.length;i++){
        if(start[i]===end[i]){
            res+=start[i];
        }else{
            break;
        }
        
    }
    return res
}
module.exports = {
    longestCommonPrefix : longestCommonPrefix
};

四*、最长递增子序列（不连续）---- 贪心+二分法

最长递增子序列_牛客题霸_牛客网

4.1 描述

4.2 思路

1）第一步：利用贪心+二分求最长递增子序列长度

下面说说贪心+二分的解法，举例说明基本思路，假设数组arr为[2, 3, 1, 2, 3]，vec数组里面存放递增子序列，maxLen数组里存放以元素i结尾的最大递增子序列长度，那么遍历数组arr并执行如下更新规则:

初始情况下，vec为[2]，maxLen[1]
接下来遇到3，由于vec最后一个元素小于3，直接更新，vec为[2,3]，maxLen[1,2]
接下来遇到1，由于vec最后的元素大于1, 我们在vec中查找大于等于1的第一个元素的下标，并用1替换之，此时vec为[1,3], maxLen[1,2,1]
接下来遇到2，由于vec最后的元素大于2，我们在vec中查找大于等于2的第一个元素的下标，并用2替换之，此时vec为[1,2], maxLen[1,2,1,2]
接下来遇到3，由于vec最后一个元素小于3，直接更新，vec为[1,2,3]，maxLen为[1,2,1,2,3]
此时vec的大小就是整个序列中最长递增子序列的长度（但是vec不一定是本题的最终解）

2）第二步：填充最长递增子序列

假设我们原始数组是arr1，得到的maxLen为[1,2,3,1,3]。

因为从元素arr[2]到arr[4]最长递增子序列的元素个数没变，所以可以得出arr[2]>arr[4];
由于我们需要找到字典序最小的递增子序列，故选择以arr[4]结尾的递增子序列。