leetcode回溯法题目解法若干

N皇后问题

• N-Queens
• N-Queens II

import java.util.ArrayList;
import java.util.List;

/*
 * @lc app=leetcode id=51 lang=java
 *
 * [51] N-Queens
 */
public class Solution {

    List<List<String>> result = new ArrayList<>();

    private static int total = 0;

    public List<List<String>> solveNQueens(int n) {
        total = n;
        int[][] board = new int[n][n];
        backtrack(board, 1);
        return result;
    }

    private void backtrack(int[][] board, int idx) {
        if (idx > total) {
            // ok
            result.add(transform(board));
            return;
        }

        for (int i = 0; i < total; i ++) {
            if (isOk(board, idx - 1, i)) {
                //
                board[idx - 1][i] = 1;
                backtrack(board, idx + 1);
                board[idx - 1][i] = 0;
            }
        }
    }

    private boolean isOk(int[][] board, int xx, int yy) {
        for (int i = 0; i < total; i++) {
            if (board[xx][i] == 1) {
                return false;
            }
            if (board[i][yy] == 1) {
                return false;
            }
        }
        int x = xx, y = yy;
        while (x < total && y >= 0)
            if (board[x ++][y --] == 1)
                return false;
        x = xx; y = yy;
        while (x < total && y < total)
            if (board[x ++][y ++] == 1)
                return false;
        x = xx; y = yy;
        while (x >= 0 && y >= 0)
            if (board[x --][y --] == 1)
                return false;
        x = xx; y = yy;
        while (x >=0 && y < total)
            if (board[x --][y ++] == 1)
                return false;
//        System.out.println("OK");
        return true;
    }

    private List<String> transform(int[][] board) {
        List<String> oneAnswer = new ArrayList<>();
        for (int i = 0; i < board.length; i ++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < board[i].length; j ++) {
                sb.append(board[i][j] == 0 ? '.' : 'Q');
            }
            oneAnswer.add(sb.toString());
        }
//        showAnswer(oneAnswer);
        return oneAnswer;
    }

    private void showAnswer(List<String> answer) {
        System.out.println();
        for (String line : answer) {
            System.out.println(line);
        }
    }

    public static void main(String[] args) {
        List<List<String>> result = new Solution().solveNQueens(4);
        System.out.println(result.size());
    }
}

Letter Combinations of a Phone Number

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.

import java.util.ArrayList;
import java.util.List;

/*
 * @lc app=leetcode id=17 lang=java
 *
 * [17] Letter Combinations of a Phone Number
 */
class Solution {
    private int[][] maps = {
        {},
        {},
        {'a', 'b', 'c'},
        {'d', 'e', 'f'},
        {'g', 'h', 'i'},
        {'j', 'k', 'l'},
        {'m', 'n', 'o'},
        {'p', 'q', 'r', 's'},
        {'t', 'u', 'v'},
        {'w', 'x', 'y', 'z'}
    };
    List<String> result = new ArrayList<>();
    public List<String> letterCombinations(String digits) {
         backtrack(digits, "", 0);
         return result;
    }
    private void backtrack(String digits, String sb, int idx) {
        if (idx >= digits.length()) {
            if (sb.length() > 0)
                result.add(sb.toString());
            return;
        }
        int mapsIdx = digits.charAt(idx) - '0';
        for (int i = 0; i < maps[mapsIdx].length; i ++) {
            backtrack(digits, sb + (char) maps[mapsIdx][i], idx + 1);
        }
    }
}

Generate Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

class Solution {
    List<String> sets = new ArrayList<>();

    // 22
    public List<String> generateParenthesis(int n) {
        produce(2 * n, 0, n, n, "");
        return sets;
    }

    private void produce(int blank, int sum, int lcnt, int rcnt, String seq) {
        if (sum < 0)
            return;

        if (blank == 0) {
            sets.add(seq);
            return;
        }

        if (lcnt > 0) {
            produce(blank - 1, sum + 1, lcnt - 1, rcnt, seq + "(");
        }

        if (rcnt > 0) {
            produce(blank - 1, sum - 1, lcnt, rcnt - 1, seq + ")");
        }
    }
}

Sudoku Solver

Write a program to solve a Sudoku puzzle by filling the empty cells.

A sudoku solution must satisfy all of the following rules:

Each of the digits 1-9 must occur exactly once in each row.

Each of the digits 1-9 must occur exactly once in each column.

Each of the the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.

Empty cells are indicated by the character ‘.’.

/*
 * @lc app=leetcode id=37 lang=java
 *
 * [37] Sudoku Solver
 */
public class Solution {
    private static class Point {
        public int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "<" + x + ", " + y + ">";
        }
    }

    static char[][] data = {
            {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
            {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
            {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
            {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
            {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
            {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
            {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
            {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
            {'.', '.', '.', '.', '8', '.', '.', '7', '9'}
    };

    public static void main(String[] args) {
        new Solution().solveSudoku(data);
        printBoard(data, "最终结果");
    }

    private static void printBoard(char[][] data, String msg) {
        System.out.println("\n" + msg + ":");
        for (int i = 0; i < data.length; i ++) {
            for (int j = 0; j < data[i].length; j++) {
                System.out.print(data[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    boolean over = false;

    public void solveSudoku(char[][] board) {
        backtrack(board, nextPoint(board, new Point(0, 0)));
    }

    private void backtrack(char[][] board, Point focus) {
        if (over || isOver(board)) {
            over = true;
            return;
        }

        if (focus == null) {
            over = true;
            return;
        }

        for (int val = 1; val <= 9 && !over; val++) {
            board[focus.x][focus.y] = (char) ('0' + val);
            if (isValid(board, focus, (char) ('0' + val))) {
                backtrack(board, nextPoint(board, focus));
            }
        }
        if (!over)
            board[focus.x][focus.y] = '.';
    }

    private boolean isValid(char[][] board, Point p, char val) {
        // 横向
        for (int i = 0; i <= 8; i++) {
            if (i != p.y && board[p.x][i] == val)
                return false;
        }
        // 纵向
        for (int i = 0; i <= 8; i++) {
            if (i != p.x && board[i][p.y] == val)
                return false;
        }
        // 方形
        for (int i = (p.x / 3 * 3); i <= (p.x / 3 * 3) + 2; i++) {
            for (int j = (p.y / 3 * 3); j <= (p.y / 3 * 3) + 2; j++) {
                if (i != p.x && j != p.y && board[i][j] == val)
                    return false;
            }
        }
//        printBoard(board, "位置" + p + ", 对值<" + (char)val + ">合适");
        return true;
    }

    private boolean isOver(char[][] board) {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                if (board[i][j] == '.')
                    return false;
            }
        }
        return true;
    }

    private Point nextPoint(char[][] board, Point p) {
        Point returnPoint = null;
        int x = p.x, y = p.y;
        while (x <= 8 && returnPoint == null) {
            for (int i = y; i <= 8; i++) {
                if (board[x][i] == '.') {
                    returnPoint = new Point(x, i);
                    break;
                }
            }
            y = 0;
            x ++;
        }
//        System.out.println(p + "  ->  " + returnPoint);
        return returnPoint;
    }
}

Combination Sum

相关问题：Combination Sum II

import java.util.ArrayList;
import java.util.List;

/*
 * @lc app=leetcode id=39 lang=java
 *
 * [39] Combination Sum
 */
class Solution {

    List<List<Integer>> result = new ArrayList();

    private int maxInt = 0;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        sort(candidates);
        maxInt = candidates[candidates.length - 1] + 1;
        backtrack(candidates, target, new ArrayList<>());
        return result;
    }

    private void sort(int[] arr) {
        for (int i = 0; i < arr.length; i ++) {
            for (int j = i; j < arr.length; j ++) {
                if (arr[i] > arr[j]) {
                    int tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }

    private void backtrack(int[] candidates, int target, List<Integer> answer) {
        if (target == 0) {
            // find the answer
//            showArray(answer);
            if (!isDuplicated(result, answer, candidates))
                result.add(new ArrayList<>(answer));
            else {
//                System.out.println("Duplicated");
            }
        } else if (target < 0) {
            return;
        }

        for (int i = 0; i < candidates.length; i++) {
            answer.add(candidates[i]);
            backtrack(candidates, target - candidates[i] , answer);
            answer.remove(answer.size() - 1);
        }
    }

    private void showArray(List<Integer> arr) {
        System.out.print("[");
        for (int i = 0; i < arr.size(); i ++) {
            System.out.print(String.valueOf(arr.get(i)) + (i == arr.size() - 1 ? "]" : ", "));
        }
        System.out.println();
    }

    private boolean isDuplicated(List<List<Integer>> result, List<Integer> oneAnswer, int[] candidates) {
        for (List<Integer> r : result) {
            if (r.size() == oneAnswer.size()) {
                int[] sr = new int[maxInt];
                int[] si = new int[maxInt];
                for (int i = 0; i < r.size(); i ++) {
//                    System.out.println(r.get(i) + " + 1");
                    sr[r.get(i)] ++;
//                    System.out.println(oneAnswer.get(i) + " + 1");
                    si[oneAnswer.get(i)] ++;
                }
                boolean isDuplicatedWithThisResult = true;
                for (int i = 0; i < candidates.length; i ++) {
                    // System.out.println(candidates[i] + "," + sr[candidates[i]] + "," + si[candidates[i]]);
                    if (sr[candidates[i]] != si[candidates[i]]) {
                        isDuplicatedWithThisResult = false;
                        continue;
                    }
                }
                if (isDuplicatedWithThisResult)
                    return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int [] arr = {8,7,4,3};
        new Solution().combinationSum(arr, 11);
    }
}

Permutations

相关问题：Permutations II

class Solution {
    List<List<Integer>> result = new ArrayList();

    private boolean[] USAGE;

    public List<List<Integer>> permute(int[] nums) {
        USAGE = new boolean[nums.length];
        List<Integer> answer = new ArrayList();
        backtrack(nums, 0, answer);
        return result;
    }

    private void backtrack(int[] nums, int idx, List<Integer> answer) {
        if (idx >= nums.length) {
            result.add(new ArrayList(answer));
            return;
        }
        for (int i = 0; i < nums.length; i ++) {
            if (!USAGE[i]) {
                answer.add(nums[i]);USAGE[i] = true;
                backtrack(nums, idx + 1, answer);
                answer.remove(answer.size() - 1);USAGE[i] = false;
            }
        }
    }
}

Permutation Sequence

class Solution {
    private boolean[] usage;
    private String result;
    private int targetIdx, currentIdx;
    private boolean over = false;
    public String getPermutation(int n, int k) {
        targetIdx = k;
        usage = new boolean[n + 1];
        StringBuilder sb = new StringBuilder();
        backtrack(n, 1, sb);
        return result;
    }

    private void backtrack(int n, int idx, StringBuilder sb) {
        if (over)
            return;
        if (idx > n) {
            currentIdx ++;
            if (currentIdx == targetIdx) {
                result = sb.toString();
                over = true;
            }
            return ;
        }
        for (int i = 1; i <= n; i ++) {
            if (over)
                break;
            if (!usage[i]) {
                sb.append(i);usage[i] = true;
                backtrack(n, idx + 1, sb);
                sb.deleteCharAt(sb.length() - 1);usage[i] = false;
            }
        }
    }
}

Combinations

class Solution {
    private List<List<Integer>> result = new ArrayList();
    private boolean[] USAGE;
    private int depth;

    public List<List<Integer>> combine(int n, int k) {
        depth = k;
        USAGE = new boolean[n + 1];
        backtrack(1, n, 1, new ArrayList<>());
        return result;
    }

    private void backtrack(int startIdx, int n, int idx, List<Integer> answer) {
        if (idx > depth) {
            result.add(new ArrayList(answer));
            return;
        }
        for (int i = startIdx; i <= n; i ++) {
            if (!USAGE[i]) {
                answer.add(i);USAGE[i] = true;
                backtrack(i + 1, n, idx + 1, answer);
                answer.remove(answer.size() - 1);USAGE[i] = false;
            }
        }
    }
}