lee动态规划 lee5 最长回文子串（ 5.22修改 ） lee516 最长回文子序列（可不连续）

最新推荐文章于 2023-01-29 12:00:09 发布
最新推荐文章于 2023-01-29 12:00:09 发布
阅读量233 收藏
点赞数
分类专栏： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengmengkuaipao/article/details/104460437
版权

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

示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

暴力解法

在记录最长回文子串的时候，可以只记录“当前子串的起始位置”和“子串长度”，不必做截取。这一步我们放在后面的方法中实现。
说明：暴力解法时间复杂度高，但是思路清晰、编写简单。由于编写正确性的可能性很大，可以使用暴力匹配算法检验我们编写的其它算法是否正确。优化的解法在很多时候，是基于“暴力解法”，以空间换时间得到的，因此思考清楚暴力解法，分析其缺点，很多时候能为我们打开思路。

public class longestPalindrome5 {
    public static void main(String[] args) {
        String s = "babaadadadfcda";
        String res = longestPalindrome(s);
        System.out.println(res);
    }

    private static String longestPalindrome(String s){
        int n = s.length();
        if(n<2) return s;
        int max = 1;
        int start = 0;
        // s.charAt(i) 每次都会检查数组下标越界，因此先转换成字符数组
        char[] num = s.toCharArray();
  // 枚举所有长度大于 1 的子串 charArray[i..j]
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                if(j-i+1>max && validHelper(num,i,j)){
                    max = j-i+1;
                    start = i;
                }
            }
        }
        return s.substring(start,start+max);
    }

 //验证子串 s[left..right] 是否为回文串
    private static boolean validHelper(char[] num, int left, int right) {
        while(left<right){
            if(num[left]!=num[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

时间复杂度：O(N^3)

动态规划 思考

第 1 步：定义状态
dp[i][j] 表示子串 s[i, j] 是否为回文子串。

第 2 步：思考状态转移方程
这一步在做分类讨论（根据头尾字符是否相等），根据上面的分析得到：
dp[i][j] = (s[i] == s[j]) and dp[i + 1][j - 1]
分析这个状态转移方程：
（1）“动态规划”事实上是在填一张二维表格，i 和 j 的关系是 i <= j ，因此，只需要填这张表的上半部分；
（2）看到 dp[i + 1][j - 1] 就得考虑边界情况。
边界条件是：表达式 [i + 1, j - 1] 不构成区间，即长度严格小于 2，即 j - 1 - (i + 1) + 1 < 2 ，整理得 j - i < 3。
这个结论很显然：当子串 s[i, j] 的长度等于 2 或者等于 3 的时候，我其实只需要判断一下头尾两个字符是否相等就可以直接下结论了。

如果子串 s[i + 1, j - 1] 只有 1 个字符，即去掉两头，剩下中间部分只有 11 个字符，当然是回文；
如果子串 s[i + 1, j - 1] 为空串，那么子串 s[i, j] 一定是回文子串。
因此，在 s[i] == s[j] 成立和 j - i < 3 的前提下，直接可以下结论，dp[i][j] = true，否则才执行状态转移。

（这一段看晕的朋友，直接看代码吧。我写晕了，车轱辘话来回说。）

第 3 步：考虑初始化
初始化的时候，单个字符一定是回文串，因此把对角线先初始化为 1，即 dp[i][i] = 1 。

事实上，初始化的部分都可以省去。因为只有一个字符的时候一定是回文，dp[i][i] 根本不会被其它状态值所参考。

第 4 步：考虑输出
只要一得到 dp[i][j] = true，就记录子串的长度和起始位置，没有必要截取，因为截取字符串也要消耗性能，记录此时的回文子串的“起始位置”和“回文长度”即可。

第 5 步：考虑状态是否可以压缩
因为在填表的过程中，只参考了左下方的数值。事实上可以压缩，但会增加一些判断语句，增加代码编写和理解的难度，丢失可读性。在这里不做状态压缩。

下面是编码的时候要注意的事项：总是先得到小子串的回文判定，然后大子串才能参考小子串的判断结果。

思路是：

1、在子串右边界 j 逐渐扩大的过程中，枚举左边界可能出现的位置；

2、左边界枚举的时候可以从小到大，也可以从大到小。

这两版代码的差别仅在内层循环，希望大家能够自己动手，画一下表格，思考为什么这两种代码都是可行的，相信会对“动态规划”作为一种“表格法”有一个更好的理解。

class Solution {
    public String longestPalindrome(String s) {
        int n=s.length();
        if(s==null) return null;
        if(n<2) return s;//预先判断

        boolean[][] dp=new boolean[n][n];
        for(int i=0;i<n;i++){// base case
            dp[i][i]=true;
        }
        int max=1; //记录最长长度 
        int start=0;//记录最长长度开始位置
        for(int j=1;j<n;j++){ // 注意循环开始情况 为j 里套着 i
            for(int i=0;i<j;i++){
                if(s.charAt(i)==s.charAt(j)){
                    if(j-i<3) {//不用再判断了 剩一个或者不剩都算回文
                        dp[i][j]=true;
                        
                    }
                    else{
                        dp[i][j]=dp[i+1][j-1];
                    }
                }else{
                    dp[i][j]=false;
                }

                if(dp[i][j]){//不substring  只是记录就可
                    int cur=j-i+1;
                    if(cur>max){
                        max=cur;
                        start=i;
                    }
                }

            }
        }
        return s.substring(start,start+max);
    }
}

中心扩散法

暴力法采用双指针两边夹，验证是否是回文子串。

除了枚举字符串的左右边界以外，比较容易想到的是枚举可能出现的回文子串的“中心位置”，从“中心位置”尝试尽可能扩散出去，得到一个回文串。

因此中心扩散法的思路是：遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。

枚举“中心位置”时间复杂度为 O(N)O(N)，从“中心位置”扩散得到“回文子串”的时间复杂度为 O(N)O(N)，因此时间复杂度可以降到 O(N^2)O(N
2
)。

在这里要注意一个细节：回文串在长度为奇数和偶数的时候，“回文中心”的形式是不一样的。

奇数回文串的“中心”是一个具体的字符，例如：回文串 “aba” 的中心是字符 “b”；
偶数回文串的“中心”是位于中间的两个字符的“空隙”，例如：回文串串 “abba” 的中心是两个 “b” 中间的那个“空隙”。

们可以设计一个方法，兼容以上两种情况：

1、如果传入重合的索引编码，进行中心扩散，此时得到的回文子串的长度是奇数；

2、如果传入相邻的索引编码，进行中心扩散，此时得到的回文子串的长度是偶数。

具体编码细节在以下的代码的注释中体现。

class Solution {
    public String longestPalindrome(String s) {
        int n=s.length();
        if(n<2) return s;
        int max=1;//最少一个字母
        String res=s.substring(0,1);//先设第一个字母为res
        for(int i=0;i<n;i++){// 遍历一遍数
            String oddstr=centerSpread(s, i, i);
            String evenstr=centerSpread(s,i,i+1);
            String maxstr=(oddstr.length()>evenstr.length()) ?oddstr:evenstr;
            if(maxstr.length()>max){
                max=maxstr.length();
                res=maxstr;
            }
        }
        return res;
    }
    public String centerSpread(String s, int i,int j){
        while(i>=0 && j<s.length()){
            if(s.charAt(i)== s.charAt(j)){
                i--;
                j++;
            }
            else{
                break;
            }
        }
        return s.substring(i+1,j);
    }
}

5.22 重写三种方法

package dailyLeetcode;

public class longestPalindrome5 {
    public static void main(String[] args) {
        String s = "babaadadadfcda";
   //     String res = longestPalindrome(s);// 暴力
   //     String res = longestPalindrome_2(s);// 动态规划
        String res = longestPalindrome_3(s);// 中心扩散
        System.out.println(res);
    }

    private static String longestPalindrome_3(String s) {
        int n = s.length();
        if(n<2) return s;
        int max = 1;
        String res = s.substring(0,1);
        for(int i=0;i<n;i++){
            String oddStr = centerHelper(s,i,i);
            String evenStr = centerHelper(s,i,i+1);
            String maxStr = (oddStr.length()>evenStr.length())?oddStr:evenStr;

            if(maxStr.length()>max){
                max = maxStr.length();
                res = maxStr;
            }
        }
        return res;
    }

    private static String centerHelper(String s, int i, int j) {
        while(i>=0 && j<s.length()){
            if(s.charAt(i) == s.charAt(j)){
                i--;
                j++;
            }
            else{
                break;
            }
        }
        return s.substring(i+1,j);
    }

    private static String longestPalindrome_2(String s) {
        int n = s.length();
        if(n<2) return s;
        int max = 1;
        int start = 0;
        boolean[][] dp = new boolean[n][n];
        char[] str = s.toCharArray();
        for(int i=0;i<n;i++){
            dp[i][i] = true;
        }
        for(int j = 1;j<n;j++){
            for(int i=0;i<j;i++){// 注意了 这里取得事i到j的范围
                if(str[i]!=str[j]){
                    dp[i][j] = false;
                }
                else {// 如果相等的时候 不能写两个else if
                    if(j-i<3)
                    {
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }
                if(dp[i][j] && j-i+1>max ){
                    max = j-i+1;
                    start = i;
                }
            }
        }
        return s.substring(start,start+max);
    }

    private static String longestPalindrome(String s){
        int n = s.length();
        if(n<2) return s;
        int max = 1;
        int start = 0;
        char[] num = s.toCharArray();
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                if(j-i+1>max && validHelper(num,i,j)){
                    max = j-i+1;
                    start = i;
                }
            }
        }
        return s.substring(start,start+max);
    }

    private static boolean validHelper(char[] num, int left, int right) {
        while(left<right){
            if(num[left]!=num[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

lee516 最长回文子序列

可不连续，输出长度

class Solution {
    public int longestPalindromeSubseq(String s) {
        int n=s.length();
        if(n<2) return n;
        int[][] dp=new int[n][n];
        for(int i=0;i<n;i++){
            dp[i][i]=1;
        }
        for(int i=n-1;i>=0;i--){//注意方向
            for(int j=i+1;j<n;j++){//注意方向
                if(s.charAt(i)==s.charAt(j)){
                    dp[i][j]=dp[i+1][j-1]+2;//注意这里要+2  求长度
                }
                else{
                    dp[i][j]=Math.max(dp[i+1][j], dp[i][j-1]);
                }
            }
            
        }
        return dp[0][n-1];
    }
}

有个大神方法，二分查找发

添加链接描述

public class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        if (len <= 1) {
            return len;
        }

        // tail 数组的定义：长度为 i + 1 的上升子序列的末尾最小是几
        int[] tail = new int[len];
        // 遍历第 1 个数，直接放在有序数组 tail 的开头
        tail[0] = nums[0];
        // end 表示有序数组 tail 的最后一个已经赋值元素的索引
        int end = 0;

        for (int i = 1; i < len; i++) {
            // 【逻辑 1】比 tail 数组实际有效的末尾的那个元素还大
            if (nums[i] > tail[end]) {
                // 直接添加在那个元素的后面，所以 end 先加 1
                end++;
                tail[end] = nums[i];
            } 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 - left) >>> 1);
                    if (tail[mid] < nums[i]) {
                        // 中位数肯定不是要找的数，把它写在分支的前面
                        left = mid + 1;
                    } else {
                        right = mid;
                    }
                }
                // 走到这里是因为 【逻辑 1】 的反面，因此一定能找到第 1 个大于等于 nums[i] 的元素
                // 因此，无需再单独判断
                tail[left] = nums[i];
            }
            // 调试方法
            // printArray(nums[i], tail);
        }
        // 此时 end 是有序数组 tail 最后一个元素的索引
        // 题目要求返回的是长度，因此 +1 后返回
        end++;
        return end;
    }

    // 调试方法，以观察是否运行正确
    private void printArray(int num, int[] tail) {
        System.out.print("当前数字：" + num);
        System.out.print("\t当前 tail 数组：");
        int len = tail.length;
        for (int i = 0; i < len; i++) {
            if (tail[i] == 0) {
                break;
            }
            System.out.print(tail[i] + ", ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] nums = new int[]{3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12};
        Solution solution = new Solution8();
        int lengthOfLIS = solution8.lengthOfLIS(nums);
        System.out.println("最长上升子序列的长度：" + lengthOfLIS);
    }
}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

萌萌，站起来
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode回文序列问题——Java
Stay Hungry Stay Foolish
08-21 309
最长回文子序列，最长回文子串，回文串数量，最长回文串长度，回文数，回文链表 最长回文子序列 使用一个二维dp记录当前序列s[i … j]的最长回文子序列长度。 当当前序列头尾字符一样时，去掉头尾字符，里面应该还是回文子序列，所以当前序列的回文子序列等于里面最长回文子序列的长度+头尾字符的个数。如对序列babab来说，dp[0][4] = dp[1][3] + 2 = 5 当当前序列头尾字符不一样...
dcm4che-core-5.22.5.jar
03-25
dcm4che-core.jar
HDU 4745 Two Rabbits（区间DP，最长非连续回文子串）
weixin_30621919的博客
03-17 129
Two Rabbits Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 1274 Accepted Submission(s): 641 Problem Description Long long ago...
最长回文串(可不连续)、构成回文串需添加的最少字符
u014381464的博客
09-25 383
寻找回文串可以正序和倒序找非连续的公共子串，动归算法，最长公共子串为a 则构成回文串需添加的最少字符为len（str）- a https://blog.csdn.net/carson0408/article/details/77776398 有空补代码...
2020-08-11贝壳笔试（回文串更改，拆数字）
qq_42003941的博客
08-12 723
一、回文串更改 对于任意一个字符串，它至少需要替换多少个字符才能将它变为回文字符串，可以选择任意一个位置的字符将其替换 输入：第一行一个整数n，表示字符串的长度，第二行n个小写字母表示字符串 输出：一个整数表示最少替换的字符串个数 import java.util.Scanner; public class test1{ public static void main(String[] args){ Scanner in=new Scanner (System.in);
【Leetcode】回文串
ys578676728的博客
04-14 225
经典题目5. 最长回文子串（多种解法）131. 分割回文串（dfs）132. 分割回文串 II（动态规划）214. 最短回文串（KMP） 5. 最长回文子串（多种解法） leetcode 5 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。 思路： 反转字符串得到s’，求s和s’的最长公共子串，并判断该子串是否对应s和s’的同一位置。时间复杂度O(n2)O...
keil5软件安装包 keil5 MDK 5.22版本
最新发布
07-02
keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本keil5 MDK 5.22版本...
Activiti5.22中文开发指南(数据库版).pdf
11-23
Activiti 5.22 中文开发指南（数据库版） Activiti 是一个基于 Java 的工作流引擎，提供了强大的工作流管理功能。在 Activiti 中，数据库是核心组件之一，负责存储工作流相关的数据。本文档将对 Activiti 5.22 的...
emWin5.22.zip_EMWIN5.22_Emwin 界面_emWin5.22移植_emwin登录界面_famousgu1
07-14
标题中的"emWin5.22.zip"表明这是一个包含了emWin 5.22版本的软件包，"EMWIN5.22_Emwin 界面"则强调了该库用于构建用户界面的能力。"emWin5.22移植"和"emwin登录界面"提示我们这个包不仅包含库本身，还可能有相关的...
dcm4che-image-5.22.5.jar
03-25
dcm4che-image-5.22.5
AMI DMI Edit_Windows Tool_501733usa_DMI-Tool_dmiedit5.22_DMI_AMI
09-30
AMI Editor for MS-DOS/DR-DOS. AMI BIOS/Firmware
AMI ATPIO DMI EDITOR
06-16
最全的AMI ATPIO DMI EDITOR集合， DOS、efi、Windows、linux下的tool都有。
AMI DMIEdit 主板信息修改工具
09-18
支持AMI主板Bios信息修改的工具，修改个性化电脑信息，序列号等。Windows环境，官方修改DMI信息的工具
DMIEDITV210.7z
07-22
支持DOS, UEFI, Linux，Windows等环境，官方修改DMI信息的工具
DmiEditWinGui bios序列编辑软件.rar
06-23
DMIEDIT最新版本，DMIEDIT修改，bios dmi信息修改 bios序列号修改
经典算法思想题目-回文子串
ybigbear的博客
01-24 613
给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
leetcode【中等】647、回文子串 / 516、最长回文子序列
qq_40707462的博客
05-10 111
思路一：动态规划（同5） class Solution: def countSubstrings(self, s: str) -> int: l=len(s) dp = [[False for _ in range(l)] for _ in range(l)] res=0 for j in range(0,l): for i in range(0,j+1): if s[i].
集訓5.22~5.30（上）
zjc0201的博客
05-30 214
Day1      小測驗，前面幾道題**題，第四題記憶化結果忘了判斷不合法的情況導致溢出，以後記得要考慮所有情況，并不是得到最優解就行了，第五題第一次在考試里寫莫隊，出師順利A了，第六題一道大組合數，竟然沒想出來，連楊輝三角都忘記碼了，寫了個30分的暴力還錯了，完敗      晚上kmp，重溫了一邊，但感覺還是不會很好的利用這個算法，主要是next數組Day2      初等數論。進制轉換，位運...
1.29
2201_75302620的博客
01-29 131
dw
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值