精华内容
下载资源
问答
  • 动态规划-回文子串c++

    2020-05-21 16:02:57
    最长回文子串 5. 最长回文子串 题目 给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。 示例 输入: "babad" 输出: "bab" 注意: "aba" 也是一个有效答案。 代码 class Solution { ...

    5. 最长回文子串

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

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

    思路
    在这里插入图片描述
    dp[i][j]数组表示:

    字符串s[i\cdots j]s[i⋯j]是否为回文子串,如果是,dp[i][j] = truedp[i][j]=true,如果不是,dp[i][j] = falsedp[i][j]=false。
    如何我们现在已经知道了dp[i+1][j-1]dp[i+1][j−1]了,那我们如何计算dp[i][j]dp[i][j]呢?通过观察,我们发现:

    • 如果s[i] == s[j]那么说明只要dp[i+1][j-1]dp[i+1][j−1]是回文子串,那么是dp[i][j]dp[i][j]也就是回文子串
    • 如果s[i] != s[j] 那么说明dp[i][j]dp[i][j]必定不是回文子串。
      在这里插入图片描述
    • 因为不存在i大于j 所以初始化下半三角都是false
    • 遍历顺序从下向上,从左到右
      注:图片来源
      代码
    class Solution {
    public:
        string longestPalindrome(string s) {
            int len  = s.size();
            if(len <= 1) return s;
            vector<vector<bool>> dp(len, vector<bool>(len, false));
            string res = s.substr(0,1);
            for(int i = 0; i < len; i++) dp[i][i]= true;
            for(int i = len-2; i >= 0; i--){
                for(int j = i+1; j < len; j++){
                    if(s[i] == s[j]){
                        if(j - i == 1) dp[i][j] = true;
                        else dp[i][j] = dp[i+1][j-1];
                        if(dp[i][j]){
                            if(j - i + 1 > res.size())  res = s.substr(i, j-i+1);
                        }
                    }
                }
            }
            return res;
        }
    };
    

    516. 最长回文子序列

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

    输入:"bbbab"
    输出:4
    

    思路
    假设我们现在知道了dp[i+1][j-1]dp[i+1][j−1],我们如何计算dp[i][j]dp[i][j]呢?我们只需要观察是s[i]s[i] 等不等于s[j]s[j]

    • 当s[i] = s[j]s[i]=s[j],那么就说明在原先的基础上又增加了回文子序列的长度,dp[i][j] = dp[i+1][j-1] + 2;
    • 当s[i]!=s[j],那么那么说明s[i]、s[j]s[i]、s[j]至少有一个不在回文子序列中。那就变成了下图所示:
      在这里插入图片描述
      DP表为:
      在这里插入图片描述
      代码
    class Solution {
    public:
        int longestPalindromeSubseq(string s) {
            int len = s.size();
            if(len <= 1) return len;
            int res = 1 ;
            vector<vector<int>>dp(len, vector<int>(len, 0));
            for(int i = 0; i < len; i++) dp[i][i] = 1;
            for(int i = len-2; i >=0; i--){
                for(int j = i+1; j <  len; 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][len-1];
        }
    };
    

    647. 回文子串

    题目
    给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。

    具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。
    示例

    输入: "abc"
    输出: 3
    解释: 三个回文子串: "a", "b", "c".
    
    输入: "aaa"
    输出: 6
    说明: 6个回文子串: "a", "a", "a", "aa", "aa", "aaa".
    

    代码

    class Solution {
    public:
        int countSubstrings(string s) {
            //dp[i][j] 表示字符串S i 到j是够为回文
            int len = s.size();
            if(len <= 1) return len;
            vector<vector<bool>> dp(len, vector<bool>(len, false));
            int res = len;
            for(int i = 0; i < len; i++)dp[i][i] = true;
            for(int i = len - 2; i >= 0; i--){
                for(int j = i + 1; j < len; j++){
                    if(s[i] == s[j]){
                        if(j - i == 1)dp[i][j] = true;
                         
                        else dp[i][j] = dp[i+1][j-1];
                    }
                    //这里有毒吧,为什么写dp[i][j] == ture少两个结果
    
                    if(dp[i][j])res++;
                         
                }
            }
            return res;
            
                
        }
    };
    

    712. 两个字符串的最小ASCII删除和

    题目
    给定两个字符串s1, s2,找到使两个字符串相等所需删除字符的ASCII值的最小和。

    示例

    输入: s1 = "sea", s2 = "eat"
    输出: 231
    解释: 在 "sea" 中删除 "s" 并将 "s" 的值(115)加入总和。
    在 "eat" 中删除 "t" 并将 116 加入总和。
    结束时,两个字符串相等,115 + 116 = 231 就是符合条件的最小和。
    注意:
    
    0 < s1.length, s2.length <= 1000。
    所有字符串中的字符ASCII值在[97, 122]之间。
    

    代码

    class Solution {
    public:
        int minimumDeleteSum(string s1, string s2) {
            
            int leni = s1.size(), lenj = s2.size();
            vector<vector<int>>dp(leni + 1, vector<int>(lenj + 1, 0));
           
            for(int i = 0; i < leni; i++){
                
                for(int j = 0; j < lenj; j++){
                    
                    if(s1[i] == s2[j]){
                        dp[i+1][j+1] = dp[i][j] + s1[i];
                    }else{
                        dp[i+1][j+1] = max(dp[i][j+1], dp[i+1][j]);
                    }
                    
                }
            }
            int sum = 0;
            for(auto c: s1) sum = sum + (int)c;
            for(auto c: s2) sum = sum + (int)c;
            return sum - 2*dp[leni][lenj];
    
        }
    };
    
    展开全文
  • 1.动态规划 2.中心扩散法 3.还有著名的马拉车算法 1.回文子串的个数 、 public class Solution14_回文子串 { /** * 方法一:中心扩散法 */ static int ans = 0; public static void main(Strin...

    一看到回文字符串,脑海里立马要想到前面两个最常用的结题思路:

    • 1.动态规划
    • 2.中心扩散法
    • 3.还有著名的马拉车算法

    1.回文子串的个数

    public class Solution14_回文子串 {
        /**
         * 方法一:中心扩散法
         */
        static int ans = 0;
     
        public static void main(String[] args) throws IOException {
            BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
            String s = bf.readLine();
            for (int i = 0; i < s.length(); i++) {
                //考虑两种情况:aba 和 abba
                centerSpread(s, i, i);
                centerSpread(s, i, i + 1);
            }
            System.out.println(ans);
        }
     
        //判断回文串的中心扩散法
        private static void centerSpread(String s, int left, int right) {
            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
                left--;
                right++;
                ans++;
            }
        }
     
        //方法二:动态规划
        private static int dp(String s) {
            int n = s.length(), ans = 0;
            boolean[][] dp = new boolean[n][n];
            for (int i = n - 1; i >= 0; i--) {
                for (int j = i; j < n; j++) {
                    dp[i][j] = (s.charAt(i) == s.charAt(j)) && (j - i <= 2 || dp[i + 1][j - 1]);
                    if (dp[i][j]) ans++;
                }
            }
            return ans;
        }
    }

    2.最长回文子串

    class Qusetion2 {
     
        //1.动态规划
        public static String longestPalindrome(String s) {
            int n = s.length();
            if (n < 2) return s;
            int maxLen = 1;
            String res = s.substring(0, 1);
            boolean[][] dp = new boolean[n][n];
            //左边界一定小于右边界,因此从右边界开始
            for (int r = 1; r < n; r++) { //表示右边界
                for (int l = 0; l < r; l++) { //表示左边界
                    // 区间应该慢慢放大
                    // 状态转移方程:如果头尾字符相等并且中间也是回文
                    // 在头尾字符相等的前提下,如果收缩以后不构成区间(最多只有 1 个元素),直接返回 True 即可
                    // 否则要继续看收缩以后的区间的回文性
                    if (s.charAt(l) == s.charAt(r) && ((r - l) <= 2 || dp[l + 1][r - 1])) {
                        dp[l][r] = true;
                        if (r - l + 1 > maxLen) {
                            maxLen = r - l + 1;
                            res = s.substring(l, r + 1);
                        }
                    }
                }
            }
            return res;
        }
     
        //2.中心扩展法
        private int start, maxLen;
     
        public String longestPalindrome1(String s) {
            if (s == null || s.length() < 2) return s;
            for (int i = 0; i < s.length(); i++) {
                //考虑中心扩散的两种情况1:aba  和 2: bb
                findMaxPalindrome(s, i, i);
                findMaxPalindrome(s, i, i + 1);
            }
            return s.substring(start, start + maxLen);
        }
     
        private void findMaxPalindrome(String s, int i, int j) {
            while (i >= 0 && j < s.length() && s.charAt(i) == s.charAt(j)) {
                i--;//向左延伸
                j++;//向右延伸
            }
            //记录每个起始点扩展的回文串的最大长度
            if (maxLen < j - i - 1) {
                start = i + 1;
                maxLen = j - i - 1;
            }
        }
    }

    3.最长不连续回文子串

    动态规划解法:dp[l][r]表示从l到r最长回文子串的长度,如果在char[l] == char[r] 那么dp[l + 1][r - 1] + 2 否则最大回文子串要么不包括char[l],要么不包括char[r] ,即在dp[l + 1][r]和dp[l][r - 1]中取最大值

    public int longestPalindrome(String s) {
        int n = s.length();
        int[][] dp = new int[n][n];//dp[l][r]表示l-r中的最长回文串
        for (int r = 0; r < n; r++) {
            dp[r][r] = 1;
            for (int l = r - 1; l >= 0; l--) {
                if (s.charAt(l) == s.charAt(r)) {
                    dp[l][r] = dp[l + 1][r - 1] + 2;
                } else {
                    dp[l][r] = Math.max(dp[l + 1][r], dp[l][r - 1]);
                }
            }
        }
        return dp[0][n - 1];
    }

     

    展开全文
  • 动态规划之最长回文子串

    万次阅读 多人点赞 2019-04-25 13:17:22
    给出一个字符串S,求S的最长回文子串的长度。 样例 字符串"PATZJUJZTACCBCC"的最长回文子串为"ATZJUJZTA",长度为9。         还是先看暴力解法:枚举子串的两个端点i和j,...

    问题:

    给出一个字符串S,求S的最长回文子串的长度。
    

    样例

    字符串"PATZJUJZTACCBCC"的最长回文子串为"ATZJUJZTA",长度为9。
    

            还是先看暴力解法:枚举子串的两个端点i和j,判断在[i, j]区间内的子串是否回文。从复杂度上来看,枚举端点需要0(n2),判断回文需要0(n),因此总复杂度是O(n3)。终于碰到一个暴力复杂度不是指数级别的问题了!但是O(n)的复杂度在n很大的情况依旧不够看。
            可能会有读者想把这个问题转换为最长公共子序列(LCS) 问题来求解:把字符串S倒过来变成字符串T,然后对S和T进行LCS模型求解,得到的结果就是需要的答案。而事实上这种做法是错误的,因为一旦S中同时存在一个子串和它的倒序,那么答案就会出错。例如字符串S= “ABCDZJUDCBA”,将其倒过来之后会变成T = “ABCDUJZDCBA”,这样得到最长公共子串为"ABCD",长度为4,而事实上S的最长回文子串长度为1。因此这样的做法是不行的。
    动态规划解决
            令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串,是则为1,不是为0。这样根据S[i]是否等于S[j],可以把转移情况分为两类:
             ①若S[i]=S[j],那么只要S[i+1]和S[j-1]是回文子串,S[i+1]至S[j-1]就是回文子串;如果S[i+1]至S[j-1]不是回文子串,则S[i]至S[j]一定不是回文子串。
             ②若S[i]!=S[j],那S[i]至S[j]一定不是回文子串。
    由此可以写出状态转移方程
    在这里插入图片描述

    边界dp[i][i]=1,dp[i][i+1]=(S[i]==S[i+1])?1:0 。
    

            到这里还有一个问题没有解决,那就是如果按照i和j从小到大的顺序来枚举子串的两个端点,然后更新dp[i]lj],会无法保证dp[i + 1][ - 1]已经被计算过,从而无法得到正确的dp[i][i]。
             如图11-4所示,先固定i=0,然后枚举j从2开始。当求解dp[0][2]时,将会转换为dp[1][],而dp[1][1]是在初始化中得到的;当求解dp[0][3]时,将会转换为dp[1][2], 而dp[1][2]也是在初始化中得到的;当求解dp[0][4]时,将会转换为dp[1][3], 但是dp[1][3]并不是已经计算过的值,因此无法状态转移。事实上,无论对ij和j的枚举顺序做何调整,都无法调和这个矛盾,因此必须想办法寻找新的枚举方式。
            根据递推写法从边界出发的原理,注意到边界表示的是长度为1和2的子串,且每次转移时都对子串的长度减了1,因此不妨考虑按子串的长度和子串的初始位置进行枚举,即第一遍将长度为3的子串的dp值全部求出,第二遍通过第一遍结果计算出长度为4的子串的dp值…这样就可以避免状态无法转移的问题。如图11-5所示,可以先枚举子串长度L (注意: L是可以取到整个字符串的长度S.len()的),再枚举左端点i,这样右端点i+ L- 1也可以直接得到。

    在这里插入图片描述
    代码:

    #include<iostream>
    #include<string>
    #include<cstdio>
    #include<algorithm>
    using namespace std;
    const int maxn=1000;
    char S[maxn];//A存序列,dp[i]存以i为结尾的连续序列的最大和
    int dp[maxn][maxn];
    int main()
    {
    	gets(S);//从下标为1开始读入
    	int len=strlen(S),ans=1;
    	memset(dp,0,sizeof(dp));
    	for(int i=0;i<len;i++)
    	{
    		dp[i][i]=1;
    		if(i<len-1)
    		{
    			if(S[i]==S[i+1])
    				{
    					dp[i][i+1]=1;
    					ans=2;//初始化时注意当前最长回文子串长度;
    				}
    		}
    	}
    	//状态转移方程
    	for(int L=3;L<=len;L++)//枚举子串长度
    		for(int i=0;i+L-1<len;i++)//枚举子串起始端点 起始端点加上子串长度(子串长度包括他
    		本身,所以要-1)必须小于总长,
    			{
    				int j=i+L-1;//子串右端点
    				if(S[i]==S[j]&&dp[i+1][j-1]==1)
    				{
    					dp[i][j]=1;
    					ans=L;//更新最长回文子串长度;
    				}
    			}
    		cout<<ans<<endl;
    }
    
    展开全文
  • 给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。 实例 输入: "abc" 输出: 3 解释: 三个回文子串: "a", "b", ...

    问题一

    给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。
    具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。

    实例

    输入: "abc"
    输出: 3
    解释: 三个回文子串: "a", "b", "c".
    

    方法一

    可以发现,回文串特点就是每个回文串都有一个中心点,左右边是对称的,那么我们就可以以中心点为基点,向两边扩散遍历,如果左右的字符相等,那么,就可以认定该子串为一个字符串。回文串长度分奇数偶数,奇数串的中心可以为长度为N的字符串的每一个字符,偶数串的中心可以为长度为N的字符串的每一个间隔,理解为俩字符中间的 |。

    代码

    class Solution {
        public int countSubstrings(String s) {
            boolean[][] isHuiWen = new boolean[s.length()][s.length()];
            for(int i = 0; i < s.length(); i++){
                for(int j = 0; j < s.length(); j++){
                    isHuiWen[i][j] = false;
                }
            }
            int p,q,m;
            //先扫描奇数的
            for(m = 0; m < s.length(); m++){
                p = q = m;
                while(p >= 0 && q < s.length() && s.charAt(p) == s.charAt(q)){  
                    isHuiWen[p][q] = true;
                    q++;
                    p--;
                }
            }
            //扫描偶数
            for(m = 0; m < s.length(); m++){
                p = m;
                q = m+1;
                while(p >= 0 && q < s.length() && s.charAt(p) == s.charAt(q)){
                    isHuiWen[p][q] = true;
                    p--;
                    q++;
                }
            }
            int num = 0;
            for(int i = 0; i < s.length(); i++){
                for(int j = 0; j < s.length(); j++){
                    if(isHuiWen[i][j] == true){
                        num++;
                    }
                }
            }
            return num;
        }
    }
    

    方法二(动态规划)

    思路

    使用动态规划, dp[i][j] 代表str[i] - str[j]是否是回文子串
    考虑单字符和双字符的特殊情况
    状态转移方程:dp[i][j] = dp[i+1][j-1] && str[i]==str[j]

    代码

    class Solution {
        public static int countSubstrings(String s) {
           boolean[][] dp =  new boolean[s.length()][s.length()];
            int res = 0;
            int i,j; //判断i到之间的字符串是不是回文串
            for(j = 0; j < s.length(); j++){   //注意:这里得先遍历j,再遍历i
                for(i = j; i >= 0; i--){
                    if(s.charAt(i) == s.charAt(j) && (j - i < 2 || dp[i+1][j-1])){
                        dp[i][j] = true;
                        res++;
                    }
                }
            }
            return res;
        }
        public static void main(String[] args) {
            String s = "aaa";
            System.out.println(countSubstrings(s));
        }
    }
    

    问题二

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

    实例

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

    思路

    第一步:首先寻找回文子串,思路同问题一相同
    第二步:使用low和high记录一下最长回文子串的位置

    代码

    输入: "babad"
    class Solution {
        public String longestPalindrome(String s) {
            boolean[][] huiwen = new boolean[s.length()][s.length()];
            if(s.length() == 0){
                return s;
            }
            int p,q;
            int max = 0;
            for(int i = 0; i < s.length(); i++){
                 p = q = i;
                 while(p >= 0 && q < s.length() && s.charAt(p) == s.charAt(q)){
                     huiwen[p][q] = true;
                     p--;
                     q++;
                 }
            }
    
            for(int i = 0; i < s.length(); i++){
                 p = i;
                 q = i + 1;
                 while(p >= 0 && q < s.length() && s.charAt(p) == s.charAt(q)){
                     huiwen[p][q] = true;
                     p--;
                     q++;
                 }
            }
            int low = 0;
            int high = 0;
            for(int i = 0; i < s.length(); i++){
                for(int j = 0; j < s.length(); j++){
                    if(huiwen[i][j] == true){
                        if(high - low < j-i){
                            high = j;
                            low = i;
                        }
                    }
                }
            }
            return s.substring(low,high+1);
        }
    }
    
    展开全文
  • 给定一个字符串 双指针2版dp
  • 647. 回文子串 给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被视作不同的子串。 示例 1: 输入:“abc” 输出:3 解释:三个...
  • (力扣—动态规划)回文子串 描述 给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。 示例 1: 输入: “abc” ...
  • 给定一个字符串,求其最长的回文子串的长度。如字符串"... 分析:典型的动态规划问题,用dp[i][j]记录字符串中从字符 i 到字符 j 中最长回文子串的长度,则 if (s.charAt(i) == s.charAt(j)) { ...
  • 给你一个字符串 s,找到 s 中最长的回文子串。 示例 1: 输入:s = “babad” 输出:“bab” 解释:“aba” 同样是符合题意的答案。 示例 2: 输入:s = “cbbd” 输出:“bb” 示例 3: 输入:s = “a” ...
  • 最长回文子串:1.寻找回文子串;2.该子串是回文子串中长度最长的。 一、O(n^3)时间复杂度方法——暴力求解 1.思想: 1)从最长的子串开始,遍历所有该原字符串的子串; 2)每找出一个字符...
  • 最长回文子串 最长回文子串的问题描述: 给出一个字符串 S,求 S 的最长回文子串的长度 例子: 字符串 “PATZJUJZTACCBCC” 的最长回文子串为 “ATZJUJZTA”,长度为 9 还是先看暴力解法,枚举子串的两个端点 i ...
  • 若S[i]==S[j],那么只要S[i+1]至S[j-1]是回文子串,S[i]至S[j]就是回文子串;反之则不是。 若S[i]!=S[j],那么S[i]至S[j]一定不是回文子串。 由此可以写出状态转移方程: 边界:dp[i][i]=1,dp[i][i+1]=(S[i]==S[i
  • 动态规划-最长回文子串 题目描述 给出一个字符串S,求S的最长回文子串的长度 样例: 字符串"PATZJUJZTACCBCC"的最长回文子串为"ATZJUJZTA",长度为9。 动态规划思想 令dp[i][j]表示S[i]至...
  • 5. 最长回文子串 给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。...子串问题,动态规划 1.最优子问题 dp[i][j],表示第i个字符到第j个字符是否是回文字符串 若dp[i+1][j-1]是回文字...
  • 动态规划解决: 令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串,是则为1,不是为0。这样根据S[i]是否等于S[j],可以把转移情况分为两类: ①若S[i]=S[j],那么只要S[i+1]和S[j-1]是回文子串,S[i+1]至S[j-1]...
  • 本文内容:使用java解决 最长回文子串 文章目录学习目标:学习内容:题目描述解题思路实现代码 题目描述 对于一个字符串,请设计一个高效算法,计算其中最长回文子串的长度。 给定字符串A以及它的长度n,请返回...
  • 最长回文子串 回文子串数 最长回文子序列 DP思想 DP和分治策略类似,讲一个问题分成几个子问题,然后地递归的求解这个几个子问题,之后合并子问题的解得到原问题的解。 不同点在于,分治策略用来解决子问题...
  • 然后找最长回文子串就是把所有的子串列出来,每个判断是否是回文串,最后找出一个最长的,这是最暴力也是最耗时的方法。当然我们也可以优化一下, 从最长的子串开始判断,依次往短的子串开始找,这样找到的第一条...
  • 题目描述 现在给你一个字符串S,请你...利用动态规划的最大回文子串模型,dp[i][j]==1的就是一个回文子串 #include<iostream> #include<cstring> #include<algorithm> using namespace std; const
  • 给定一个字符串,你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被计为是不同的子串。 输入: “abc” 输出: 3 解释: 三个回文子串: “a”, “b”, ...
  • 给定一个字符串 s,找到 s 中最长的回文子串。你可以假设s 的最大长度为 1000。 示例 1: 输入: "babad" 输出: "bab" 注意: "aba" 也是一个有效答案。 示例 2: 输入: "cbbd" 输出: "bb" 解题思路: ...
  • 1.求最长回文子串 使用动态规划 状态:如果s[i+1]…s[j-1]是回文串,而且s[i]=s[j],那么s[i]…s[j]也是回文串 所以状态转移数组dp[i] [j]表示s[i…j]是否是一个回文串 class Solution { public: string ...
  • 聊聊恶心的回文子串引言那就刷一下吧最笨法(暴力法)动态规划解法两栈一列法 引言 熟悉算法的朋友应该都了解算法中有一大块关于字符串的题,鉴于我们在程序设计语言中体会到的字符串,潜意识里很容易就把这部分题...
  • 动态规划:最长回文子串 & 最长回文子序列

    万次阅读 多人点赞 2018-10-20 15:51:49
    一、题目 所谓回文字符串,就是一个字符串,从...最长回文子串 和 最长回文子序列(Longest Palindromic Subsequence)是指任意一个字符串,它说包含的长度最长的回文子串和回文子序列。 例如:字符串 “ABCDDCEFA...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,106
精华内容 3,642
关键字:

动态规划回文子串