算法27：最长回文子序列长度（力扣516题）——样本模型 + 范围模型

适合java程序员的算法

已于 2024-01-11 16:04:38 修改

阅读量609

点赞数

分类专栏：算法文章标签：算法

于 2023-05-30 14:39:46 首次发布

本文链接：https://blog.csdn.net/chen_yao_kerr/article/details/130945603

版权

算法专栏收录该内容

55 篇文章 1 订阅

订阅专栏

题目：

给定一个字符串str，返回这个字符串的最长回文子序列长度

比如 str = “a12b3c43def2ghi1kpm” * 最长回文子序列是“1234321”或者“123c321”，返回长度7

这一题使用样本模型，也可以解决，只需要生成一个逆序字符串就可以了。因为回文子序列，逆序以后，回文子序列依旧保持原来的顺序结构。

样本模型：

递归版本：

public static int longestPalindromeSubseq(String s)
    {
        if (s == null || s.isEmpty()) {
            return 0;
        }
        char[] s1 = s.toCharArray();
        char[] s2 = new char[s1.length];
        int position = 0;
        //生成逆序
        for (int i = s1.length-1; i >=0; i--) {
            s2[position++] = s1[i];
        }

        return process(s1, s2, s1.length-1, s2.length-1);
    }

    public static int process(char[] s1, char[] s2, int i, int j)
    {
        if (i == 0 && j == 0){
            return s1[i] == s2[j] ? 1 : 0;
        }
        else if (i == 0) {
            return  s1[i] == s2[j] ? 1 : process(s1, s2, i, j-1);
        }
        else if (j == 0) {
            return  s1[i] == s2[j] ? 1 : process(s1, s2, i-1, j);
        }
        else {

            int p1 = process(s1, s2, i, j-1);

            int p2 = process(s1, s2, i-1, j);

            int p3 = s1[i] == s2[j] ? process(s1, s2, i-1, j-1) + 1 : 0;

            return Math.max(p1, Math.max(p2, p3));
        }
    }

测试结果：

动态规划版本：

package code03.动态规划_07;

/**
 * 给定一个字符串str，返回这个字符串的最长回文子序列长度
 * 比如 ： str = “a12b3c43def2ghi1kpm”
 * 最长回文子序列是“1234321”或者“123c321”，返回长度7
 *
 * https://leetcode.com/problems/longest-palindromic-subsequence/
 */
public class PalindromeSubsequence_05
{
    public static int longestPalindromeSubseq(String str) {

        if (str == null || str.isEmpty()) {
            return 0;
        }
        char[] s1 = str.toCharArray();
        char[] s2 = new char[s1.length];
        int position = 0;
        //生成逆序
        for (int i = s1.length-1; i >=0; i--) {
            s2[position++] = s1[i];
        }

        //以s1做行，s2做列
        int[][] dp = new int[ s1.length][s2.length];

        int index1 = s1.length - 1;
        int index2 = s2.length - 1;

        //根据递归   if (index1 == 0 && index2 == 0)  而来
        dp[0][0] = s1[0] == s2[0] ? 1 : 0;

        //根据递归  else if (index1 == 0)  而来, 此处代表先处理 第一行的所有列
        for (int i = 1; i <= index2; i++) {
            dp[0][i] = s1[0] == s2[i] ? 1 : dp[0][i-1];
        }

        //根据递归  else if (index2 == 0)  而来, 此处代表先处理 第一列的所有行
        for (int j = 1; j <= index1; j++) {
            dp[j][0] = s1[j] == s2[0] ? 1 : dp[j-1][0];
        }

        //通用case  根据递归中最后一个else而来
        for (int row = 1; row <= index1; row++) {
            for (int col = 1; col <= index2; col++) {

                //根据 int p1 =  process(s1, s2, index1, index2-1) 改写
                int p1 = dp[row][col - 1];

                //根据 int p2 =  process(s1, s2, index1-1, index2) 改写
                int p2 = dp[row -1][col];

                //int p3 = s1[index1] == s2[index2] ? (process(s1, s2, index1-1, index2-1) + 1) : 0;
                int p3 = s1[row] == s2[col] ? (dp[row -1][col -1] + 1) : 0;

                dp[row][col] = Math.max(p1, Math.max(p2, p3));
            }
        }

        //返回值对应递归中的下标
        return dp[index1][index2];
    }
}

样本模型，在上一篇已经详细的说过了，具体推导过程可以参照算法27：最长公共子序列——样本模型（4）_chen_yao_kerr的博客-CSDN博客

样本模型，都是以样本的最后一个元素为基础进行讨论分析的。

而范围模型，则是以样本数据的开头和结尾进行讨论的。

递归版本的范围模型

package code03.动态规划_07;

/**
 * 给定一个字符串str，返回这个字符串的最长回文子序列长度
 * 比如 ： str = “a12b3c43def2ghi1kpm”
 * 最长回文子序列是“1234321”或者“123c321”，返回长度7
 *
 * https://leetcode.com/problems/longest-palindromic-subsequence/
 */
public class PalindromeSubsequence_05_opt1
{
    public static int longestPalindromeSubseq(String str)
    {
        if (str == null || str.isEmpty()) {
            return 0;
        }

        return process(str.toCharArray(), 0, str.length() -1);
    }

    //范围模型，需要讨论样本数据的开头和结尾
    public static int process(char[] str, int left, int right)
    {
        //如果长度为1,也就是说字符串只有一个字符
        if (left == right) {
            return 1;
        }

        //字符串只有2个元素. 如果第一个元素和第二个元素相同，则说明回文
        //长度为2. 否则，最长子回文只有1，因为我们默认的子序列回文长度就是为1.
        if (left == right -1) {
            return str[left] == str[right] ? 2 : 1;
        }

        /**
         * 最长回文子序列, 有可能出现以下情况
         * 1. 包含结尾，不包含开头
         * 2. 包含开头，不包含结尾
         * 3. 既不包含开头，也不包含结尾
         * 4. 既包含开头，也包含结尾
         */

        //包含结尾，不包含开头
        int p1 = process(str, left + 1, right);
        //包含开头，不包含结尾
        int p2 = process(str, left, right - 1);
        //既不包含开头，也不包含结尾
        int p3 = process(str, left + 1, right - 1);
        //既包含开头，也包含结尾
        int p4 = str[left] != str[right] ? 0 : (2 + process(str, left + 1, right - 1));
        //也可以改写成 int p4 = str[left] != str[right] ? 0 : (2 + p3);
        
        return Math.max(Math.max(p1, p2), Math.max(p3, p4));
    }


    public static void main(String[] args) {
        System.out.println(longestPalindromeSubseq("a12b3c43def2ghi1kpm"));
    }
}

测试结果：

分析过程

1. 假设字符串为 a12a21b，我们知道最长回文子序列为12a21, 那么它的长度就是5.

2. 构建二维数组. 行和列都是数组的下标。递归的传入参数 0 和 str.length() -1，分别代表数组的左边开始位置和右边开始位置。将left作为行，right作为列，那么可以推导出如下的表格信息

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)
1(1)	x
2(2)	x	x
3(a)	x	x	x
4(2)	x	x	x	x
5(1)	x	x	x	x	x
6(b)	x	x	x	x	x	x

3. 根据递归的

if (left == right) {
    return 1;
}

可以推算出对角线全部为 1.

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1
1(1)	x	1
2(2)	x	x	1
3(a)	x	x	x	1
4(2)	x	x	x	x	1
5(1)	x	x	x	x	x	1
6(b)	x	x	x	x	x	x	1

4. 根据递归

if (left == right -1) {
    return str[left] == str[right] ? 2 : 1;
}

可以推算出：

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1
1(1)	x	1	1
2(2)	x	x	1	1
3(a)	x	x	x	1	1
4(2)	x	x	x	x	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

5. 核心推算过程

//包含结尾，不包含开头。我们知道（left，right）依赖（left+1, right）,即下一行
int p1 = process(str, left + 1, right);
//包含开头，不包含结尾. 我们知道（left，right）依赖（left, right -1）即前一列
int p2 = process(str, left, right - 1);
//既不包含开头，也不包含结尾。我们知道（left，right）依赖（left+1, right -1）即前一列的下一行
int p3 = process(str, left + 1, right - 1);
//既包含开头，也包含结尾。我们知道（left，right）依赖（left+1, right -1）即前一列的下一行
int p4 = str[left] != str[right] ? 0 : (2 + process(str, left + 1, right - 1));

也就是说（left，right）依赖当前行的前一列、下一行的当前列和前一行的前一列/

也就是说想要知道dp[4][6]的值，必须先知道dp[4][5] dp[5][6] 和 dp[5][5] 的值。而这几个值已经推出来了，那就拿到最大值 1.

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1
1(1)	x	1	1
2(2)	x	x	1	1
3(a)	x	x	x	1	1
4(2)	x	x	x	x	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

还是按照以上的信息，根据前一列、下一行的当前列以及前一行的前一列可以推算出结果。

以dp[3][6]为例子。 dp[3][5]为3， dp[4][6]为3，dp[4][5]为1. 并且字符串下标3的值为a，6的位置为b， a!=b, 因此维持最大值3. 如果相等，那就额外再加 2。

依次类推，第一个变化的位置为dp[2][4]

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1	1
1(1)	x	1	1	1
2(2)	x	x	1	1	3
3(a)	x	x	x	1	1	1
4(2)	x	x	x	x	1	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

依次类推，得到完整的表格信息

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1	1	3	3	5	5
1(1)	x	1	1	1	3	5	5
2(2)	x	x	1	1	3	3	3
3(a)	x	x	x	1	1	1	1
4(2)	x	x	x	x	1	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

动态规划版本

package code03.动态规划_07;

/**
 * 给定一个字符串str，返回这个字符串的最长回文子序列长度
 * 比如 ： str = “a12b3c43def2ghi1kpm”
 * 最长回文子序列是“1234321”或者“123c321”，返回长度7
 *
 * https://leetcode.com/problems/longest-palindromic-subsequence/
 */
public class PalindromeSubsequence_05_opt2
{
    public static int longestPalindromeSubseq(String str)
    {
        if (str == null || str.isEmpty()) {
            return 0;
        }

        //构造一个 n * n的矩阵
        char[] s = str.toCharArray();
        int[][] dp = new int[s.length][s.length];

        //最后一行的最后一列比较特殊，会出现数组越界，需要单独设置
        dp[s.length-1][s.length-1] = 1;
        for (int i = 0; i < s.length - 1 ; i++) {
            //根据递归  if (left == right) 得到对角线全部为1
            dp[i][i] = 1;
            //根据递归 if (left == right -1) { 得到对角线的后一列值
            dp[i][i+1] = s[i] == s[i+1] ? 2 : 1;
        }

        //由于倒数第一、第二行已经推算出来了，因此从倒数第三行开始推算
        for (int row = s.length - 3; row >= 0; row--)
        {
            //从倒数第一行开始推算。并且列需要随着行变化而变化
            for (int col = row + 2; col < s.length ; col++)
            {
                //包含开头，不包含结尾
                int p1 = dp[row + 1][col];
                //包含结尾，不包含开头
                int p2 = dp[row][col - 1];
                //既不包含开头，也不包含结尾
                int p3 =  dp[row + 1][col - 1];
                //既包含开头，也包含结尾
                int p4 = s[row] != s[col] ? 0 : (2 + dp[row + 1][col - 1]);

                dp[row][col] = Math.max(Math.max(p1, p2), Math.max(p3, p4));
            }
        }

        return dp[0][s.length-1];
    }



    public static void main(String[] args) {
        System.out.println(longestPalindromeSubseq("a12b3c43def2ghi1kpm"));
    }
}

测试结果：

优化动态规划：

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1	1
1(1)	x	1	1	1
2(2)	x	x	1	1	3
3(a)	x	x	x	1	1	1
4(2)	x	x	x	x	1	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

dp[2][4]位置是第一次发生变化的。下一轮，我们会推算出如下结果：

	0(a)	1(1)	2(2)	3(a)	4(2)	5(1)	6(b)
0(a)	1	1	1	3
1(1)	x	1	1	1	3
2(2)	x	x	1	1	3	3
3(a)	x	x	x	1	1	1	1
4(2)	x	x	x	x	1	1	1
5(1)	x	x	x	x	x	1	1
6(b)	x	x	x	x	x	x	1

而dp[1][5]位置依赖 dp[1][4] 、 dp[2][5] 和 dp[2][4].

但是dp[1][4] 和 [2][5]已经推算出来了，他们都依赖dp[2][4]。

也就是说dp[1][4] 和 [2][5]至少都是大于或等于dp[2][4位置的数据的，

我们的逻辑是获取到最大值，既然能够拿到大于等于它的值，那么dp[1][5]直接依赖dp[1][4] 和 [2][5]就可以了，没必要再去依赖较小的dp[2][4]值了。

因此，单独的依赖左下方，即p3就可以省略

递归优化：

package code03.动态规划_07;

/**
 * 给定一个字符串str，返回这个字符串的最长回文子序列长度
 * 比如 ： str = “a12b3c43def2ghi1kpm”
 * 最长回文子序列是“1234321”或者“123c321”，返回长度7
 *
 * https://leetcode.com/problems/longest-palindromic-subsequence/
 */
public class PalindromeSubsequence_05_opt1
{
    public static int longestPalindromeSubseq(String str)
    {
        if (str == null || str.isEmpty()) {
            return 0;
        }

        return process(str.toCharArray(), 0, str.length() -1);
    }

    //范围模型，需要讨论样本数据的开头和结尾
    public static int process(char[] str, int left, int right)
    {
        //如果长度为1,也就是说字符串只有一个字符
        if (left == right) {
            return 1;
        }

        //字符串只有2个元素. 如果第一个元素和第二个元素相同，则说明回文
        //长度为2. 否则，最长子回文只有1，因为我们默认的子序列回文长度就是为1.
        if (left == right -1) {
            return str[left] == str[right] ? 2 : 1;
        }

        /**
         * 最长回文子序列, 有可能出现以下情况
         * 1. 包含结尾，不包含开头
         * 2. 包含开头，不包含结尾
         * 3. 既不包含开头，也不包含结尾
         * 4. 既包含开头，也包含结尾
         */

        //包含结尾，不包含开头
        int p1 = process(str, left + 1, right);
        //包含开头，不包含结尾
        int p2 = process(str, left, right - 1);
        //既不包含开头，也不包含结尾
        //int p3 = process(str, left + 1, right - 1);
        //既包含开头，也包含结尾
        int p4 = str[left] != str[right] ? 0 : (2 + process(str, left + 1, right - 1));

        return Math.max(Math.max(p1, p2), p4);
    }


    public static void main(String[] args) {
        System.out.println(longestPalindromeSubseq("a12b3c43def2ghi1kpm"));
    }
}

动态规划版本优化：

package code03.动态规划_07;

/**
 * 给定一个字符串str，返回这个字符串的最长回文子序列长度
 * 比如 ： str = “a12b3c43def2ghi1kpm”
 * 最长回文子序列是“1234321”或者“123c321”，返回长度7
 *
 * https://leetcode.com/problems/longest-palindromic-subsequence/
 */
public class PalindromeSubsequence_05_opt2
{
    public static int longestPalindromeSubseq(String str)
    {
        if (str == null || str.isEmpty()) {
            return 0;
        }

        //构造一个 n * n的矩阵
        char[] s = str.toCharArray();
        int[][] dp = new int[s.length][s.length];

        //最后一行的最后一列比较特殊，会出现数组越界，需要单独设置
        dp[s.length-1][s.length-1] = 1;
        for (int i = 0; i < s.length - 1 ; i++) {
            //根据递归  if (left == right) 得到对角线全部为1
            dp[i][i] = 1;
            //根据递归 if (left == right -1) { 得到对角线的后一列值
            dp[i][i+1] = s[i] == s[i+1] ? 2 : 1;
        }

        //由于倒数第一、第二行已经推算出来了，因此从倒数第三行开始推算
        for (int row = s.length - 3; row >= 0; row--)
        {
            //从倒数第一行开始推算。并且列需要随着行变化而变化
            for (int col = row + 2; col < s.length ; col++)
            {
            /*    //包含开头，不包含结尾
                int p1 = dp[row + 1][col];
                //包含结尾，不包含开头
                int p2 = dp[row][col - 1];
                //既不包含开头，也不包含结尾
                int p3 =  dp[row + 1][col - 1];
                //既包含开头，也包含结尾
                int p4 = s[row] != s[col] ? 0 : (2 + dp[row + 1][col - 1]);

                dp[row][col] = Math.max(Math.max(p1, p2), Math.max(p3, p4));*/

                //包含开头，不包含结尾
                int p1 = dp[row + 1][col];
                //包含结尾，不包含开头
                int p2 = dp[row][col - 1];
                dp[row][col] = Math.max(p1, p2);

                if (s[row] == s[col] ) {
                    dp[row][col] = Math.max(dp[row][col], 2 + dp[row + 1][col - 1]);
                }
            }
        }
        return dp[0][s.length-1];
    }



    public static void main(String[] args) {
        System.out.println(longestPalindromeSubseq("a12b3c43def2ghi1kpm"));
    }
}