【算法】【字符串模块】添加最少字符使得当前字符变成回文字符串

前言

当前所有算法都使用测试用例运行过，但是不保证100%的测试用例，如果存在问题务必联系批评指正~

在此感谢左大神让我对算法有了新的感悟认识！

问题介绍

原问题
给定一个字符串str，可以插入字符到字符串中，要求添加最少的字符使得当前字符变成回文字符串。

解决方案

原问题：
1、首先通过动态规划来求出添加最少的字符个数n
· 定义dp[i][j]为str[i…j]变成回文字符串所需要的最小内存
· 如果char[i]= char[j]，说明当前字符串的两端都相等，dp[i][j] = dp[i+1][j-1]， 左下角
· 如果不相等.dp[i][j] = Math.min(dp[i+1][j], dp[i][j-1]) + 1
2、申请一个长度为n+char.len的字符数组charsNew
3、从dp[0][chars.len]开始往回计算，通过动态规划的逆过程开始往回计算，如 dp[0][chars.len-1]走到dp[0][chars.len-2] 说明 charsNew的两端添加字符chars[chars.len-1]

代码编写

java语言版本

原问题：

    /**
     * 二轮测试：问题一
     * @return
     */
    public static String getPalindromeCp1(String string) {
        if (string == null || string.length() == 0) {
            return null;
        }
        char[] chars = string.toCharArray();
        int[][] dp = getDpCp1(chars);
        char[] res = new char[dp[0][dp.length - 1] + chars.length];
        // 开始添加字符
        int i = 0, j = chars.length-1;
        int i2 = 0, j2 = res.length-1;
        int count = dp[0][chars.length-1];
        while (i <= j) {
            if (chars[i] == chars[j]) {
                // 相等直接复制
                res[i2++] = chars[i++];
                res[j2--] = chars[j--];
            }else {
                // 不相等看dp
                char tmp = 0;
                if (dp[i+1][j] <= dp[i][j-1]) {
                    tmp = chars[i--];
                }else {
                    tmp = chars[j--];
                }
                res[i2++] = tmp;
                res[j2--] = tmp;

            }
            count--;
        }
        return String.valueOf(res);
    }


    /**
     * chars变成回文字符串所添加的最少字符数量
     * @param chars
     * @return
     */
    private static int[][] getDpCp1(char[] chars) {
        int[][] dp = new int[chars.length][chars.length];
        // 先填斜线
        for (int i = 0; i < chars.length; i++) {
            dp[i][i] = 0;
        }
        for (int j = 1; j < chars.length; j++) {
            for (int i = j-1; i >= 0 ; i--) {
                if (chars[i] == chars[j]) {
                    // 左右边相等的情况,最小值-1，注意0的情况
                    int min = Math.min(dp[i + 1][j], dp[i][j - 1]);
                    // 如果min为0说明原来就是回文字符串，这波多了一个字符就需要再添一个，否则原来的减少一个
                    dp[i][j] = min == 0? 1 : min - 1;
                }else {
                    //左右不相等的情况
                    int min = Math.min(dp[i + 1][j], dp[i][j - 1]);
                    // 不相等说明又多了一个累赘
                    dp[i][j] = min == 0? 1 : min + 1;
                }
            }
        }
        return dp;
    }

c语言版本

正在学习中

c++语言版本

正在学习中

思考感悟

其实有进阶问题，但是进阶问题的解法与当前题目解法并不太相关，所以这里我不贴上来了。这道题在动态规划里面有相似的题目，dp[i][j]定义比较容易想到，但是这里的递归状态关系有一点点难，当时这个点想了比较久，不过想通了以后这道题还是比较简单的。
主要几个要点：
1、如果当前dp[i][j]子串的两端相等，那么其实两端的字符不需要补新字符使字符串变成回文字符串，所以和dp[i+][j-1]相同
2、两端不相等说明两端的字符都分别需要新增一个字符使得其变成回文字符串，当时卡住的一个点就是如果后面的字符又补充了当前一端的字符比如：ABCA，这个时候仅计算ABC,右边的A还没有计算会不会影响结果呢？其实当计算到ABCA时，发现两端相等了，说明ABC和BCA两个子串都不会再影响结果，结果直接等于BC子串的结果，即dp[i+][j-1],到这里我才恍然大悟。。。

写在最后

方案和代码仅提供学习和思考使用，切勿随意滥用！如有错误和不合理的地方，务必批评指正~
如果需要git源码可邮件给2260755767@qq.com
再次感谢左大神对我算法的指点迷津！