回溯模板384751

Posted 2021-09-08 保护眼睛

剑指offer

• • • 回溯模板
    • 剑指 Offer 38. 字符串的排列
    • 剑指 Offer 47. 礼物的最大价值
    • 剑指 Offer 51. 数组中的逆序对

回溯模板

private void backtrack("原始参数") {
    //终止条件(递归必须要有终止条件)
    if ("终止条件") {
        //一些逻辑操作（可有可无，视情况而定）
        return;
    }
    for (int i = "for循环开始的参数"; i < "for循环结束的参数"; i++) {
        //一些逻辑操作（可有可无，视情况而定）

        //做出选择

        //递归
        backtrack("新的参数");
        //一些逻辑操作（可有可无，视情况而定）

        //撤销选择
    }
}

剑指 Offer 38. 字符串的排列

class Solution38 {
    public static String[] permutation(String s) {
        Set<String> res = new HashSet<>();
        backtrack(s.toCharArray(), "", new boolean[s.length()], res);

        return res.toArray(new String[res.size()]);
    }

    private static void backtrack(char[] chars, String curString, boolean[] visited, Set<String> res) {
        //边界条件判断，当选择的字符长度等于原字符串长度的时候，说明原字符串的字符都已经选完了
        if (curString.length() == chars.length) {
            res.add(curString);
            return;
        }
        for (int i = 0; i < chars.length; i++) {
            //已经选择过的就不能再选了
            if (visited[i])
                continue;
            //表示选择当前字符
            visited[i] = true;
            //把当前字符选择后，到树的下一层继续选
            backtrack(chars, curString + chars[i], visited, res);
            //递归往回走的时候要撤销选择
            visited[i] = false;
        }
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(permutation("abc")));
    }
}

剑指 Offer 47. 礼物的最大价值

class Solution47 {
    public static int maxValue(int[][] grid) {
        int row = grid.length;
        int col = grid[0].length;

        for (int i = 1; i < col; i++) {
            grid[0][i] = grid[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < row; i++) {
            grid[i][0] = grid[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                grid[i][j] = Math.max(grid[i - 1][j], grid[i][j - 1]) + grid[i][j];
            }
        }

        return grid[row - 1][col - 1];
    }

    public static void main(String[] args) {
        System.out.println(maxValue(new int[][]  {{1,3,1},{1,5,1},{4,2,1}}));
    }
}

剑指 Offer 51. 数组中的逆序对

class Solution51 {
    static int count = 0;

    public static int reversePairs(int[] nums) {
        mergerSort(nums);

        return count;
    }

    public static void mergerSort(int[] array) {
        mergerSortRec(array, 0, array.length - 1);
    }

    public static void mergerSortRec(int[] array, int low, int high) {
        if (low >= high) return;

        int mid = (high - low) / 2 + low;

        mergerSortRec(array, low, mid);
        mergerSortRec(array, mid + 1, high);
        merger(array, low, mid, high);
    }

    private static void merger(int[] array, int low, int mid, int high) {
        int[] tmp = new int[high - low + 1];
        int k = 0;
        int s1 = low;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = high;

        while (s1 <= e1 && s2 <= e2) {
            if (array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            } else {
                count += (mid - s1 + 1);
                tmp[k++] = array[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = array[s1++];
        }

        while (s2 <= e2) {
            tmp[k++] = array[s2++];
        }

        for (int i = 0; i < tmp.length; i++) {
            array[low + i] = tmp[i];
        }
    }

    public static void main(String[] args) {
        int[] array = {1, 3, 2, 3, 1};

        System.out.println(reversePairs(array));

//        System.out.println(Arrays.toString(array));
    }
}