动态规划实现添加或删除字符使得原字符串为回文串

问题一：给定一个字符串，在字符串末尾添加字符，使得新字符串位回文字符串，求解需要添加的最少字符个数，并给出添加后构成的回文

　　思路：将原字符串str1逆序构成另一个字符串str2，然后求出原字符串和逆序串的最大公共子序列的长度，用原字符串的长度减去最大公共子序列的长度就是需要添加的字符个数min；求出构成的回文串，即在原字符串的基础上，添加上从逆序的min->str2.length，就可以构成回文串

public class Test3 {

    static int[][] result;
    static String str1 = "ABCBDAB";
    public static void main(String[] args) {
        
        StringBuffer str2 = new StringBuffer();
        for (int i = str1.length() - 1; i >= 0; i--) {
            str2.append(str1.charAt(i));
        }
        result = new int[str1.length()+1][str2.length()+1];
        
        LCS(str1, str2);

        int min = str1.length() - result[str1.length()][str2.length()];
        System.out.println("构造回文串最少添加的个数为:" + min);
        StringBuffer str = new StringBuffer(str1);
        for (int i = min-1; i < str2.length(); i++) {
            str.append(str2.charAt(i));
        }
        System.out.println("构造出的回文字符串为:" + str);
    }
    
    /**
     * 求出最大公共子序列的长度  并记录构造表信息
     * @param str1
     * @param str2
     */
    static void LCS(String str1, StringBuffer str2) {
        /*
         * 初始化二位数组的边界
         */
        for (int i = 0; i <= str1.length(); i++) {
            result[i][0] = 0;
        }
        for (int i = 0; i <= str2.length(); i++) {
            result[0][i] = 0;
        } 
        for (int i = 1; i <= str1.length(); i++) {
            for (int j = 1; j <= str2.length(); j++) {
                if(str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    result[i][j] = result[i - 1][j - 1] + 1;
                } else if(result[i - 1][j] >= result[i][j-1]) {
                    result[i][j] = result[i - 1][j];
                } else {
                    result[i][j] = result[i][j - 1];
                }
            }
        }
    }
}

　　输出结果为

　　

问题二：给定一个字符串str，可以从中删除一些字符串，使得剩下的字符串成为一个回文字符串，如何保证删除之后的字符串位最长，求出需要删除的字符个数

　　思路：同样运用动态规划的方式求解，二维表dp[][]表示子串str[i...j]需要最少删除几个字符可以使得新的字符串位回文字符串。考虑简答情况，如果str长度等于1，那么不需要删除，即删除个数为0；如果远字符串长度为2，那么任意删除一个，就变为回文串了；如果长度大于2，若str[i] == str[j],那么dp[i][j] = 0，表示已经是一个回文串，不需要删除，如果str[i]≠str[j]，则需要删除。具体实现方式为，将str[i+1][j]变为回文串或者将str[i][j-1]变为回文串，比较两种方式代价小的，然后更新dp[i][j]=min(dp[i+1][j]+dp[i][j-1]) + 1;

　　代码实现：

    /**
     * 删除一个字符串中的字符  使其成为回文串
     */
    static int deleteToPalindrome(String str) {
        for(int i =1; i<str.length(); i++) {
            if(str.charAt(i) == str.charAt(i-1)) {
                dp[i-1][i] = 0;
            } else {
                dp[i-1][i] = 1;
            }
            
            for (int j = i-2; j > -1; j--) {
                if(str1.charAt(j) == str.charAt(i)) {
                    dp[j][i] = dp[j+1][i-1];
                } else {
                    dp[j][i] = Math.min(dp[j+1][i], dp[j][i-1]) + 1;
                }
            }
        }
        return dp[0][str.length()-1];
    }

　　　运行结果：测试str为ab3bd