leetcode1312.让字符串成为回文串的最少插入次数

第一种写法：递归

class Solution {
    private int minInsertions(String s, int left, int right) {
        //1.当字符串长度不超过1时不需要操作就已经是回文的了
        if (left >= right) {
            return 0;
        }
        //2。字符串长度超过1时
        //2.1字符串前后两个字符相等，不需要进行操作
        if (s.charAt(left) == s.charAt(right)) {
            return minInsertions(s, left + 1, right - 1);
        }
        //2.2字符串前后两个字符不相等，人为操作左或者右添加一个相等字符的操作数是1
        return 1 + Math.min(minInsertions(s, left + 1, right), minInsertions(s, left, right - 1));
    }
    public int minInsertions(String s) {
        return minInsertions(s, 0, s.length() - 1);
    }
}

第二种写法：记忆化搜索

class Solution {
    private int[][] memory;
    private int minInsertions(String s, int left, int right) {
        //1.当字符串长度不超过1时不需要操作就已经是回文的了
        if (left >= right) {
            return 0;
        }
        //2.当记忆数组当中已经存储了这个值时，直接返回
        if (memory[left][right] != -1) {
            return memory[left][right];
        }
        //3。字符串长度超过1时
        //3.1字符串前后两个字符相等，不需要进行操作
        if (s.charAt(left) == s.charAt(right)) {
            return memory[left][right] = minInsertions(s, left + 1, right - 1);
        }
        //3.2字符串前后两个字符不相等，人为操作左或者右添加一个相等字符的操作数是1
        return memory[left][right] = 1 + Math.min(minInsertions(s, left + 1, right), minInsertions(s, left, right - 1));
    }
    public int minInsertions(String s) {
        memory = new int[s.length()][s.length()];
        for (int[] ints : memory) {
            Arrays.fill(ints, -1);
        }
        return minInsertions(s, 0, s.length() - 1);
    }
}

第三种写法：递推

class Solution {
    public int minInsertions(String s) {
        int n = s.length();
        int[][] dp = new int[n][n];
        for (int i = n - 2; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                dp[i][j] = s.charAt(i) == s.charAt(j) ? dp[i + 1][j - 1] : 1 + Math.min(dp[i + 1][j], dp[i][j - 1]);
            }
        }
        return dp[0][n - 1];
    }
}