【PHP解法==LeetCode（动态规划4-（最长子序列））】300.最长上升子序列 && 376.摆动序列 && 5.最长回文子串 && 516.最长回文子序列 && 最长公共子序列/串

最新推荐文章于 2023-02-02 11:56:10 发布
最新推荐文章于 2023-02-02 11:56:10 发布
阅读量468 收藏 2
点赞数
分类专栏： ——LeetCode 文章标签： PHP 动态规划 LeetCode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010365335/article/details/88298728
版权

目录

300.最长上升子序列

376.摆动序列

5.最长回文子串

516.最长回文子序列

最长公共子序列 && 最长公共子串

300.最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

说明:

  • 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
  • 你算法的时间复杂度应该为 O(n2) 。

进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

LIS（i）表示以第 i 个数字为结尾的最长上升子序列的长度

LIS（i）表示在[0...i] 的范围内，选择数组nums[ i ] 可以获得的最长上升子序列的长度

LIS（i） = max（1+ LIS（j）if nums[i] > nums[j]）

解法:如示例

（1）初始化所有元素的最长上升子序列为 1 

（2）第一个元素10，不变；第二个元素9,9<10,构不成上升序列，依旧为1；第三个元素2,2比10,9都小，也构不成上升子序列，不变

 （3）第四个元素为5,5比10,9小，比2大，结果为1+ （以2结尾的最长上升子序列长度为1） = 2

（4）第五个元素为3,3比10,9小，比2大，比5小，结果为1+ （以2结尾的最长上升子序列长度为1） = 2

（5）第六个元素为7,3比10,9小，比2,5,3大，结果为1+ （以2，5，3结尾的最长上升子序列长度为1）,取大值为3

（6）第七个元素为101,101比10,9,2,5,3,7大，结果为1+ （以10,9,2,5,3,7结尾的最长上升子序列长度为1）,取大值为4；

          第八个元素为18,18比10,9,2,5,3,7大，结果为1+ （以10,9,2,5,3,7结尾的最长上升子序列长度为1）,取大值为4；

（7）将取得的dp再遍历一次，取其中最大的值即可

class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function lengthOfLIS($nums) {
        $len = count($nums);          //初始化长度
        if($len == 0) return 0;
        $dp = [];                     //dp[i] 表示以nums[i]为结尾的最长上升子序列长度
        for($i = 0;$i < $len; ++$i){    
            $dp[$i] = 1;              //初始化当前的dp为 1
            for($j = 0;$j<$i;++$j){   //再从头遍历一次，到 i 下标
                if($nums[$j] < $nums[$i]){              //如果找到比num[i]下的，即有一个上升子序列
                    $dp[$i] = max($dp[$i], 1+$dp[$j]);  //取大值
                }
            }
        }
        //取得的dp遍历一遍取最大值
        $res = 1;
        foreach($dp as $v){
            $res = max($res,$v);
        }
        return $res;
    }
}

376.摆动序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

示例 1:

输入: [1,7,4,9,2,5]
输出: 6 
解释: 整个序列均为摆动序列。

示例 2:

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。

示例 3:

输入: [1,2,3,4,5,6,7,8,9]
输出: 2

进阶:
你能否用 O(n) 时间复杂度完成此题?

分析：获得最长的摆动序列，可以获得每一点对应的最长摆动序列，该题需要判断两个状态，新的元素点是要对应摆动序列的上升点还是下降点。因此可以用两个动态规划数组up[i]和down[i]来标记：记录到第i个元素为止以上升沿和下降沿结束的最长“摆动”序列长度。

解法：

（1）初始化所有点的摆动序列为1 ，up[i] = down[i] = 1

（2）遍历数组，如果nums[i]>nums[i-1]，表明第i-1到第i个元素是上升的，因此up[i]只需在down[i-1]的基础上加1即可，而down[i]保持down[i-1]不变

（3）如果nums[i]<nums[i-1]，表明第i-1到第i个元素是下降的，因此down[i]只需在up[i-1]的基础上加1即可，而up[i]保持up[i-1]不变

（4）如果nums[i]==nums[i-1]，不考虑进摆动序列中，则up[i]保持up[i-1]，down[i]保持down[i-1]

（5）比较最终以上升沿和下降沿结束的最长“摆动”序列长度即可获取最终结果

优化：

每次up和down都只取前一个元素，如nums[i]>nums[i-1]时，up取前一个down+1，且down本身不变，复制给当前的down[i]，再前面的数之后都不会在访问了。所以可以把O（n）的空间复杂度，降为O（1）。只使用up和down两个变量。

如果nums[i]<nums[i-1]，表明第i-1到第i个元素是下降的，因此down = up + 1，而up不变

class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function wiggleMaxLength($nums) {
        $len = count($nums);                    //初始化长度
        if($len < 2) return $len;               //长度0：数组空，返回0；长度1，只有一个序列，返回1
        $up = $down = 1;                        //初始化当前摆动序列为1，记录当前位置的摆动序列长度，当前状态为上，还是下
        for($i = 1; $i < $len; ++$i){           //从第二个元素开始遍历
            //不考虑 前后元素相等的情况
            if($nums[$i] > $nums[$i-1]){        //如果当前元素大于后面的元素，则该点为上升沿，状态是下降沿时 + 1
                $up = $down + 1;
            }elseif($nums[$i] < $nums[$i-1]){   //如果当前元素小于后面的元素，则该点为下降沿，状态是上升沿沿时 + 1
                $down = $up + 1;
            }
        }
        //取摆动序列的最大值，结尾的数不管是上升沿还是下降沿
        return $up > $down ? $up:$down;
    }
}

5.最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

该题有多重解法，本文介绍如下四种

解决速度（由慢到快）：暴力解法（10836ms） > 动态规划（3816ms）>中心扩展法（436ms）>马拉车算法（36ms）

（1）暴力解法：从第一个字符开始遍历，截取到最后的一个字符，每次获得的字符串翻转，判断是否是回文串，比较大值

（2）动态规划：用dp[i][j]表示从j到i的字符串是否为回文串。

         dp[i][j]回文字符串的子串也是回文，即如果dp[i][j]是回文，则dp[i-1][j+1]也是回文子串。

         因此可以反过来判断，要判断dp[i][j]是否是回文，则只需判断s[i]==s[j] && dp[i-1][j+1]也是回文。

         有特殊情况如有“bb”没有dp[i-1][j+1]，因此对于该情况当s[i]==s[j]时，只要 i-j ==1 即可判断为true

（3）中心扩展法：把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(N^2)。

         遍历一遍字符串，求出每个字符串对应的中心扩散回文串最大长度

（4）马拉车算法：最长回文子串——马拉车算法详解 参考其他博文得出答案

  • 插入特殊字符：为了不考虑字符串的奇偶性；在头尾加上其他的特殊字符^$，可以免去判断数组是否越界的问题
  • 计算半径数组 r ，关键公式：$r[$i] = min($maxRight-$i,$r[2*$center-$i]);
  • 最大的半径既是所求答案
/****************  暴力解法  ****************/
class Solution {
    /**
     * @param String $s
     * @return String
     */
    function longestPalindrome($s) {
        $len = strlen($s);
        if($len < 2) return $s;         //初始化判断
        $max = $s[0];
        for($i=0;$i<$len;$i++){         //从每一个字符开始，截取到最后一个字符
            for($j=$i+1;$j<$len;++$j){
                $str = substr($s, $i,$j-$i+1);  //正向字符串
                $restr = strrev($str);          //反向字符串
                if($str == $restr && strlen($str) > strlen($max)){
                    $max = $str;        //比较是否是回文串，且比当前最大的子串长
                }
            }
        }
        return $max;
    }
}
/****************  动态规划  ****************/
class Solution {
    /**
     * @param String $s
     * @return String
     */
    function longestPalindrome($s) {
        $len = strlen($s);
        if($len < 2) return $s;         //初始化判断
        $dp = [];                       //初始化动态规划dp数组，dp[i][j]表示从j到i的字符串是否为回文串
        $right = $left = 0;             //初始化最长的最优节点
        for($i=0;$i<$len;++$i){
            $dp[$i][$i] = true;         //只有一个元素的时候肯定为true
            for($j=$i-1;$j>=0;--$j){    //遍历到第i个元素，再倒退判断是否为回文串
                //头i尾j两个元素相等，且dp[i-1][j+1]是回文串，即dp[i][j]也是回文串
                //特殊情况,“bb”,此时dp[i-1][j+1]=dp[j][i]此时数组不成立，不存在截取的反向字符串
                $dp[$i][$j] = $s[$i] == $s[$j] && ($i-$j==1 || $dp[$i-1][$j+1]);
                if($dp[$i][$j] && ($i-$j)>($right-$left)){
                    $right = $i;        //截取的字符串的长度大于之前求得的左右长度，则取的左右下标点
                    $left = $j;
                }
            }
        }
        return substr($s,$left,$right-$left+1); //截取字符串
    }
}
/****************  中心扩展法  ****************/
class Solution {
    private $s,$len;
    /**
     * @param String $s
     * @return String
     */
    function longestPalindrome($s) {
        $len = strlen($s);
        if($len < 2) return $s;         //初始化判断
        $this->len = $len;              //使其成为成员变量
        $this->s = $s;
        $left = $right = 0;             //定义左右边界
        for($i=0;$i<$len;++$i){
            $lenji = $this->centerExpand($i,$i);    //奇数中心扩散，判断该点的回文长度
            $lenou = $this->centerExpand($i,$i+1);  //偶数中心扩散
            $maxLen = max($lenji,$lenou);           //取最大
            if($maxLen > $right-$left+1){
                $right = $i + floor($maxLen/2);     //取新的左右值
                $left = $i - floor(($maxLen-1)/2);  //其本身也包含在内，因此要($maxLen-1)
            }
        }
        return substr($s,$left,$right-$left+1); //截取字符串
    }
    private function centerExpand($left,$right){
        while($left>=0 && $right<$this->len && $this->s[$left] == $this->s[$right]){
            $left--;$right++;
        }
        //当不满足条件是，左右都再进了一位，此时不是常规的$right-$left+1，而是要-1
        return $right-$left-1;
    }
}
/****************  马拉车算法  ****************/
class Solution {
    /**
     * @param String $s
     * @return String
     */
    function longestPalindrome($s) {
        $len = strlen($s);
        if($len < 2) return $s;         //初始化判断
        $str = '^#'.implode('#', str_split($s)).'#$';   //分割字符串，使奇偶性统一
        $len = strlen($str);            //计算改好的字符串长度
        $r = array_fill(0, $len, 0);    //初始化半径数组
        $center = $maxRight = 0;        //初始化偏移量：中心点和回文串最大右点
        $maxStr = '';                   //结果，最长的回文串
        for($i=1;$i<$len;++$i){
            if($i<$maxRight){
                $r[$i] = min($maxRight-$i,$r[2*$center-$i]);    //计算当前回文路径的长度
            }
            while ($str[$i-$r[$i]-1] == $str[$i+$r[$i]+1]) {    //扩展回文子串南京
                $r[$i] ++;
            }
            if($i+$r[$i] > $maxRight){  //如果超出最右的点，则更新中心点和右节点
                $maxRight = $i+$r[$i];
                $center = $i;           
            }
            if(1+2*$r[$i] > strlen($maxStr)){       //计算当前回文子串是否大于记录的结果
                $maxStr = substr($str,$i-$r[$i],2*$r[$i]+1);
            }
        }
        return str_replace('#', '', $maxStr);
    }
}

516.最长回文子序列

给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。

示例 1:
输入:"bbbab"

输出:4

一个可能的最长回文子序列为 "bbbb"。

示例 2:
输入:"cbbd"

输出:2

一个可能的最长回文子序列为 "bb"。

分析：遍历每个子串，构造dp数组，dp[i][j]表示从i到j的最长回文子序列长度。

状态转移方程：当某子串s(i,j)中s[i]与s[j]相等时，即长到一个回文子序列，因此该子串的最长回文子序列长度等于去掉头尾两字符后新子串的最长回文子序列长度+2。方程：dp[i][j] = dp[i + 1][j - 1] + 2

当s[i]与s[j]不相等时，则dp[i][j] = max(de[i + 1][j],dp[i][j - 1]），取任一端较长的回文子序列作为新的长度

class Solution {
    /**
     * @param String $s
     * @return Integer
     */
    function longestPalindromeSubseq($s) {
        $len = strlen($s);              //初始化长度判断
        if($len<2) return $len;
        $dp = [];                       //初始化动态规划数组
        for($i=0;$i<$len;$i++){
            $dp[$i][$i] = 1;            //一个字符肯定是字符串
            for($j=$i-1;$j>=0;$j--){
                if($s[$i] == $s[$j]){
                    $dp[$i][$j] = $dp[$i-1][$j+1]+2;                //找到一个回文子序列，为前一个坐标 + 2（两个字符）
                }else{
                    $dp[$i][$j] = max($dp[$i-1][$j],$dp[$i][$j+1]); //取两端较大值
                }
            }
        }
        return $dp[$len-1][0];
    }
}

最长公共子序列 && 最长公共子串

LCS：Longest Common Sequence （LCS）

由两个维度进行动态规划

LCS（m,n）：S1[0...m] 和 S2[0...n]的最长公共子序列的长度

两种情况：

（1）S1[m] == S2[n] ：LCS（m,n） = 1+LCS（m-1,n-1）是公共子序列的一部分，计入公共子序列+1

（2）S1[m] ! = S2[n] ：LCS（m,n） = max(LCS（m-1,n）,LCS（m,n-1）) 两个字符串往前缩一个，取较大值

解法：如下图ABCD,AEBD

（1）ABCD 和 AEBD，首先找到了一个D，最长子序列+1，下一步只需要考察ABC和AEB

（2）C和B不等，则可以考察ABC往前缩一缩，AB和AEB ； AEB往前缩一缩，ABC和AE比较。这两个比较的最长公共子序列

（3）以左边为例，AB和AEB 找到B相等，最长子序列+1，下一步考虑A和AE

（4）A和E不相等，则可以考察A往前缩一缩，‘’和AEB，空字符串不比较，直接返回 ； AE往前缩一缩，A和A比较。这两个比较的最长公共子序列

（5）A和A相等，最长子序列+1，下一步考虑‘’和‘’，两个空字符串，直接返回。以此类推，求出最长公共子序列

class Solution {
    function LCS($s1,$s2) {         
        $len1 = strlen($s1);            //计算出两个字符串的长度
        $len2 = strlen($s2);            
        $dp = [];
        for($i=0;$i<$len1;$i++){        //开始遍历两个字符串，求出dp[i][j] 字符串s1到i和字符串s2到j的最长公共子序列
            for($j=0;$j<$len2;$j++){
                if($s1[$i] == $s2[$j]){
                    $dp[$i][$j] = $dp[$i-1][$j-1]+1;                //子序列加1
                }else{
                    $dp[$i][$j] = max($dp[$i-1][$j],$dp[$i][$j-1]); //求出一侧的最大子序列即可
                }
            }
        }
        return $dp[$len1-1][$len2-1];
    }
}

 最长公共子串是最长公共子序列的特殊形式，它必须要有连续性，此时的dp[i][j]不是记录字符串s1到i和字符串s2到j的最长公共子序列，而是记录字符串s1到i和字符串s2到j的最长公共子串

LCS（m,n）：S1[0...m] 和 S2[0...n]的最长公共子串的长度

两种情况：

（1）S1[m] == S2[n] ：LCS（m,n） = 1+LCS（m-1,n-1）是公共子串的一部分，计入公共子序列+1

（2）S1[m] ! = S2[n] ：LCS（m,n） = 0 考虑连续性，该点肯定不是公共子串

class Solution {
    function LCS($s1,$s2) {         
        $len1 = strlen($s1);            //计算出两个字符串的长度
        $len2 = strlen($s2);            
        $dp = [];
        $res = 0;
        for($i=0;$i<$len1;$i++){        //开始遍历两个字符串，求出dp[i][j] 字符串s1到i和字符串s2到j的最长公共子串长度
            for($j=0;$j<$len2;$j++){
                if($s1[$i] == $s2[$j]){
                    $dp[$i][$j] = $dp[$i-1][$j-1]+1;   //最长公共子串长度加1
                    $res = max($dp[$i][$j],$res);      //记录最长的子串
                }else{ 
                    $dp[$i][$j] = 0;                   //如果不相等，该位置节点为0，肯定不是公共子串
                }
            }
        }
        return $res;
    }
}

 

YY-帆S
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划之最长子序列问题
Rosun
10-07 1020
动态规划之最长子序列问题问题：给定一个序列a1,a2,a3,a4,⋯,ana_1,a_2,a_3,a_4,\cdots,a_n ，求该序列中最长的子序列s1,s2,⋯,sm,(m<=n)s_1,s_2,\cdots,s_m,(m<=n),子序列为严格的递增序列。
javascript-leetcode面试题解动态规划问题之第300题最长上升子序列-题解.zip
最新发布
03-16
本题解聚焦于LeetCode的第300题——最长上升子序列（Longest Increasing Subsequence, LIS），这是一个典型的动态规划问题。 动态规划是算法设计的一种策略，通过将复杂问题分解成更小的子问题来解决。在最长上升子...
第四讲：最长上升子串
qq_46470984的博客
07-15 418
给出一个长度为n的由正整数构成的序列，你需要从中删除一个正整数，很显然你有很多种删除方式，你需要对删除这个正整数以后的序列求其最长上升子串，请问在所有删除方案中，最长的上升子串长度是多少。假设删除i点，如果i点前面的最长上升子串的最大值小于右边最长上升子串的最小值，则就可以将它们相加。所以根据这个方法我们可以先预处理出以i为结束的最大上升子串的所有值，和以i为开始的最大上升子串的所有值。，则称这连续的若干个整数构成的子串为上升子串，在所有的上升子串中，长度最长的称为最长上升子串。...
最长上升子序列问题（LIS问题）与最长不上升子序列问题的四种方法（c++ 模板代码）
ylh的博客
02-02 2694
LIS问题与 L不IS问题 的模板代码，四种方法，动态规划，树状数组，线段树，二分查找
【NOIP1999普及组】导弹拦截题解（DP+单调性优化+二分）
hzk_cpp的博客
02-19 397
题目：luogu1020. 题目大意：第一问求一个最长不上升子序列，第二问求方案数，也就是最长上升子序列的长度. 我们现在知道LIS问题有一个O(n2)O(n^2)O(n2)的算法，但是这个算法在这个问题中并不能拿到满分. 我们现在考虑第一个问题的优化，我们考虑到枚举到点iii的时候，最长的长度为f[i]f[i]f[i]，然后我们再记录一个值g[i]g[i]g[i]，表示长度为iii的子序列的结尾...
DASD_116.torrent
12-19
DASD_116.torrent
DP-LeetCode1143. 最长公共子序列（Python）
12-21
在计算机科学中，最长公共子序列（Longest Common Subsequence，LCS）问题是一个经典的动态规划问题，它的目标是找到两个或多个字符串之间的最长子序列，这个子序列不必连续，但必须保持原顺序。在给定的题目中，...
DP、二分-LeetCode300. 最长上升子序列（Python）
12-21
在LeetCode的第300题“最长上升子序列”中，目标是找出给定无序整数数组中的最长上升子序列（Longest Increasing Subsequence, LIS）的长度。上升子序列是指序列中的元素逐个严格递增，但不一定是连续的。例如，对于...
javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip
03-16
本压缩包文件“javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip”包含了关于动态规划解决方案的详细解析，这是一道典型的算法面试题。 动态规划是一种解决复杂问题的有效方法，它通过将...
1490. 最长上升子串(前后缀分解)
唯爱你不弃∞
06-08 327
给出一个长度为 n 的由正整数构成的序列，你需要从中删除一个正整数，很显然你有很多种删除方式，你需要对删除这个正整数以后的序列求其最长上升子串，请问在所有删除方案中，最长的上升子串长度是多少。 这里给出最长上升子串的定义：即对于序列中连续的若干个正整数，满足 ai+1>ai，则称这连续的若干个整数构成的子串为上升子串，在所有的上升子串中，长度最长的称为最长上升子串。 输入格式 输入第一行仅包含一个正整数 n，表示给出的序列的长度。 接下来一行有 n 个正整数，即这个序列，中间用空格隔开。 输出格式 输
最长上升子序列（LIS）算法
紫芝的博客
07-25 1万+
LIS定义 LIS（Longest Increasing Subsequence）最长上升子序列  一个数的序列bi，当b1 &lt; b2 &lt; … &lt; bS的时候，我们称这个序列是上升的。 对于给定的一个序列(a1, a2, …, aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)， 这里1 &lt;= i1 &lt; i2 &lt; … &lt; iK ...
《算法笔记》第十一章动态规划
R.I.P Kobe Bryant
06-27 354
《算法笔记》第十一章动态规划
力扣-第5题-最长回文子串-PHP实现
丁丁丁梦涛的博客
03-29 269
class Solution { /** * @param String $s * @return String */ function longestPalindrome($s) { //一个字母重复N编的情况 if (count(array_count_values(str_split($s))) == 1) { return $s; } $subS = ''; .
最长回文子串（Longest Palindromic Substring）——三种时间复杂度的解法
热门推荐
qq_32354501的博客
04-27 6万+
    子串：小于等于原字符串长度由原字符串中任意个连续字符组成的子序列    回文：关于中间字符对称的文法，即“aba”(单核)、“cabbac”(双核)等    最长回文子串：1.寻找回文子串；2.该子串是回文子串中长度最长的。一、O(n^3)时间复杂度方法——暴力求解1.思想：    1）从最长的子串开始，遍历所有该原字符串的子串；    2）每找出一个字符串，就判断该字符串是否为回文；  ...
Leetcode300——最长上升子序列(动态规划)
Uupton的博客
06-05 3407
题目描述：给定一个无序的整数数组num，找到其中最长上升子序列的长度。   示例: 输入：[10，9，2，5，3，7，101，18] 输出：4 解释：最长的上升子序列是[2，3，7，101]，它的长度是4     典型的动态规划题目，定义一个数组dp，其中dp[i]代表以第num[i]为结尾取得的最长长度，最后返回最大的那个dp[i]就行了， 所以这道题的重点在于怎么求得dp[i...
总结最长回文子串的几种做法 Longest Palindrome Substring
系统 运维
03-16 243
题目是：找出一个字符串中的最长回文子串。 例如：abcbcbb的最长回文子串是bcbcb 首先一种常见的错误方法是把原字符串S倒转过来成为S‘，以为这样就将问题转化成为了求S和S’的最长公共子串的问题。反例S="abacdfgdcaba"，若按这种解法得到答案是："abacd"，显然不是回文，而正确答案是"aba" PS：这也是LeetCode的一道题：http://blog.csdn....
最长不降子序列nlogn写法
weixin_43751631的博客
04-15 207
转自大佬已经停更的博客 今天花了很长时间终于弄懂了这个算法……毕竟找一个好的讲解真的太难了，所以励志我要自己写一个好的讲解QAQ 这篇文章是在懂了这个问题n^2解决方案的基础上学习。 解决的问题：给定一个序列，求最长不下降子序列的长度（nlogn的算法没法求出具体的序列是什么） 定义：a[1…n]为原始序列，d[k]表示长度为k的不下降子序列末尾元素的最小值，len表示当前已知的最长子序列的长度。...
动态规划，最长回文子序列(java实现)，输入character，算法应该返回carac
csdn问鼎
04-25 1985
因为考试要考动态规划，所以研究了下算法，参考了网上许多资料，但是自己总结一次，印象会更加深刻。 源题目是输入character,这里换一个短点的，好分析一点，以bcdca为例。 以db[i][j]代表从字符索引i到字符索引j的最长回文子序列。当然db[0][4]就是指的bcdca的最长回文子序列。其实这个问题和最长公共子序列问题非常像。 接下来，我们考虑如何求db[0][4]的最长回文子序列。 我
4张GIF图帮助你理解二叉查找树算法
bbs375的博客
10-09 1412
二叉查找树（Binary Search Tree），也称二叉搜索树，是指一棵空树或者具有下列性质的二叉树： 任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；任意节点的左、右子树也分别为二叉查找树；没有键值相等的节点。 二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为O(log n)。二叉
最长公共子序列c++代码_leetcode(动态规划)-1143. 最长公共子序列
06-06
好的，以下是最长公共子序列的C++代码（使用动态规划）： ```cpp class Solution { public: int longestCommonSubsequence(string text1, string text2) { int m = text1.size(), n = text2.size(); vector...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值