暴力递归转动态规划（七）

题目
LeetCode原题-最长回文子序列
给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = “bbbab”
输出：4
解释：一个可能的最长回文子序列为 “bbbb” 。
示例 2：

输入：s = “cbbd”
输出：2
解释：一个可能的最长回文子序列为 “bb” 。

换句话说，就是删减完的字符串读出来左右两边是一样的：
如字符串 String s = “as1d2jk3a3jkh2gv1d”，最长回文子序列就是123a321。

这道题解法可参考上篇文章最长公共子序列。
将给定的字符串s进行逆序，生成新的字符串s1，求字符串s和字符串s1的最长公共子序列的长度即为最长回文子序列的长度。
举例： String s = “as1d2jk3a3jkh2gv1d” String s1 = “d1vg2hkj3a3kj2d1sa”。
公共子序列为：123a321，即为所求的最长回文子序列。

代码：

public static int lpsl1(String str) {
        if (null == str || str.length() == 0) {
            return 0;
        }

        char[] str1 = str.toCharArray();
        char[] str2 = reverse(str1);

        return process(str1, str2, str1.length - 1, str2.length - 1);
    }

    public static char[] reverse(char[] str) {
        int N = str.length;
        char[] str1 = new char[N];

        for (int i = 0; i < str.length; i++) {
            str1[i] = str[--N];
        }
        return str1;
    }

    public static int process(char[] str1, char[] str2, int i, int j) {
        if (i == 0 && j == 0) {
            return str1[i] == str2[j] ? 1 : 0;
        } else if (i == 0) {
            if (str1[i] == str2[j]) {
                return 1;
            } else {
                return process(str1, str2, i, j - 1);
            }
        } else if (j == 0) {
            if (str1[i] == str2[j]) {
                return 1;
            } else {
                return process(str1, str2, i - 1, j);
            }
        } else {
            int p1 = process(str1, str2, i - 1, j);
            int p2 = process(str1, str2, i, j - 1);
            int p3 = str1[i] == str2[j] ? 1 + process(str1, str2, i - 1, j - 1) : 0;

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

刚才的方法是根据公共子序列推演出来的方法，那现在让我们来直面这个问题，同样是采用暴力递归+动态规划的方式来进行解答。

暴力递归
依然是从暴力递归开始，写出暴力递归方法后优化成动态规划。
暴力递归方法主要是返回str[L…R]范围内的最大回文子序列。
共有以下几种情况：

1. base case：让L = R时，说明只剩一个字符，每个字符的本身都算是自己的回文子序列，所以return 1。
   1.1 如果L = R - 1时，还L 到 R 位置剩两个字符，如果这两个字符相等，说明回文子序列的长度为2，否则每个字符都是自己单独的回文子序列，返回1。

base case考虑完之后，就剩下其余的共4种情况：

1. 回文子序列可能不以L位置结尾，但是必须以R位置结尾。
2. 回文子序列可能不以R位置结尾，但是必须以L位置结尾。
3. 回文子序列即不以L位置结尾，也不以R位置结尾。
4. 回文子序列必须以L位置结尾 && 必须以R位置结尾。

根据这几种情况，来写递归方法。
注：下面的递归方法在LC中跑，会因为超时不通过，但是通过给的例子可以发现，不是逻辑性错误，是因为超时。后续将暴力递归优化成动态规划就好了。

代码

public static int lps2(String s) {
        if (null == s || s.length() == 0) {
            return 0;
        }

        if (s.length() == 1) {
            return 1;
        }
        char[] str = s.toCharArray();
        return process2(str,0,str.length - 1);
    }
	//递归方法返回 str[L...R]范围内的最大回文子序列
    public static int process2(char[] str, int L, int R) {
        if (L == R) {
            return 1;
        } else if (L == R - 1) {
            return str[L] == str[R] ? 2 : 1;
        } else {

            int p1 = process2(str, L + 1, R);
            int p2 = process2(str, L, R - 1);
            int p3 = process2(str, L + 1, R - 1);
            int p4 = str[L] == str[R] ? 2 + process2(str, L + 1, R - 1) : 0;
            return Math.max(Math.max(p1,p2),Math.max(p3,p4));
        }
    }

动态规划
依然是根据上面暴力递归的代码改动态规划，根据代码可发现，可变参数是L 和 R，变化范围是 0 ~ str.lengtth - 1。所以可以确定dp表的大小。

代码
从暴力递归优化成动态规划的第一版代码，代码中有一些小技巧。
比如说根据base case给dp表赋值时，先将dp[N - 1][N - 1]赋值为 -1 （根据base case L = R得知），再用第一个循环将 L = R 和 L = L + 1 赋值。（先赋值dp[N - 1][ N - 1]能够确保不越界）
第二个循 L = N - 3开始 R 从 L + 2开始，是因为第一个循环已经将dp表的最后两行填满了，所以 L 从 N - 3开始填充，R 从 L + 2位置开始。
在根据递归代码可以看出，递归中调用process(L + 1，R ) ，process(L，R - 1) 和 process(L + 1，R - 1)可以看出调用的依赖关系是左、下和左下三个位置。所以整个填充顺序如图所示：

   if (null == s || s.length() == 0) {
            return 0;
        }

        if (s.length() == 1) {
            return 1;
        }
        char[] str = s.toCharArray();
        int N = str.length;
        int[][] dp = new int[N][N];
        dp[N - 1][N - 1] = 1;
        for (int i = 0; i < N - 1; i++) {
            dp[i][i] = 1;
            dp[i][i + 1] = str[i] == str[i + 1] ? 2 : 1;
        }


        for (int L = N - 3; L >= 0; L--) {
            for (int R = L + 2; R < N; R++) {
                int p1 = dp[L + 1][R];
                int p2 = dp[L][R - 1];
                int p3 = dp[L + 1][R - 1];
                int p4 = str[L] == str[R] ? 2 + dp[L + 1][R - 1] : 0;

                dp[L][R] = Math.max(Math.max(p1, p2), Math.max(p3, p4));
            }
        }
        return dp[0][N - 1];
    }

再次优化
根据依赖位置（左、下和左下）可以看出，左下的位置是没有必要的，因为求的是最大的回文子序列，左下是（ L + 1, R - 1）的位置，它的范围一定比（L + 1,R） 和 （L , R - 1）小，所以不需要它，那么只需要p1,p2和p4进行比较即可，而p4只有在str[L] == str[R]时，才参与比较，所以还可以进一步优化。

代码

public static int dp2(String s) {
        if (null == s || s.length() == 0) {
            return 0;
        }

        if (s.length() == 1) {
            return 1;
        }
        char[] str = s.toCharArray();
        int N = str.length;
        int[][] dp = new int[N][N];
        dp[N - 1][N - 1] = 1;
        for (int i = 0; i < N - 1; i++) {
            dp[i][i] = 1;
            dp[i][i + 1] = str[i] == str[i + 1] ? 2 : 1;
        }


        for (int L = N - 3; L >= 0; L--) {
            for (int R = L + 2; R < N; R++) {
                dp[L][R] = Math.max(dp[L + 1][R],dp[L][R - 1]);
                if (str[L] == str[R]){
                    dp[L][R] = Math.max((dp[L][R]),(2 + dp[L + 1][R - 1]));
                }
            }
        }
        return dp[0][N - 1];
    }