【第30天】耗时很长，但我又回来了！！

最新推荐文章于 2025-12-06 07:43:37 发布

原创最新推荐文章于 2025-12-06 07:43:37 发布 · 70 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

本文介绍了三个使用Java解决的算法问题：1.如何重构机票路线以得到可行的行程；2.实现N皇后问题的解决方案，展示如何放置皇后以避免冲突；3.解决数独问题的回溯算法。每个问题都涉及到了回溯法在解决约束满足问题中的应用。

1.Reconstruct Itinerary

本身挺直观的题，但很容易出错。用set记录使用过的tickets中的index，然后每次遇到一种arrangement以后，在backtracking的if那里比一下哪个lexical order更小。但发现不用这样。因为数组本身不大，可以将它排序以后，这样满足if的第一个list就是我们要找的了。所以，用return true就可以找到了，不用继续往下找了。

卡哥用map记录飞行次数的方法更简单。他不排序，先过了一遍tickets记录每个dest的数量。这样其实更好。

PS: java的list.remove(i)的i是指index。如果要remove这个object，且list是Integertype的话，需要list.remove(new Integer(i))之类的。

class Solution {
    private boolean first = true;
    private List<String> tmp = new ArrayList<>();
    private List<String> res = new ArrayList<>();
    private Set<Integer> indexSet = new HashSet<>();

    public List<String> findItinerary(List<List<String>> tickets) {
        Collections.sort(tickets, new Comparator<List<String>>(){
            @Override
            public int compare(List<String> list1, List<String> list2){
                return list1.get(1).compareTo(list2.get(1));
            }
        });
        res.add("JFK");
        // System.out.println(tickets.toString().toString());
        backtracking(tickets, "JFK");
        return tmp;
    }

    private void removeFromBack(String dest){
        for(int i = res.size()-1; i >= 0; --i){
            if(res.get(i).equals(dest)){
                res.remove(i);
                break;
            }
        }
    }

    private boolean backtracking(List<List<String>> tickets, String dest){
        if(indexSet.size() == tickets.size()){
            // if(first){
            //     first = false;
            //     tmp = new ArrayList<>(res);
            // }else{
            //     boolean ans = tmp.toString().compareTo(res.toString()) <= 0;
            //     if(ans){
            //         return;
            //     }else{
            //        tmp = new ArrayList<>(res);
            //     }
            // }
            tmp = new ArrayList<>(res);
            return true;
        }

        for(int i = 0; i < tickets.size(); ++i){
            if(dest.equals(tickets.get(i).get(0)) && !indexSet.contains(i)){
                indexSet.add(i);
                res.add(tickets.get(i).get(1));
                // System.out.println(indexSet.size() + "  " + tickets.size());
                // System.out.println(res.toString());
                // System.out.println();
                if(backtracking(tickets, tickets.get(i).get(1))) return true;
                removeFromBack(tickets.get(i).get(1));
                indexSet.remove(i);
            }
        }
        return false;
    }
}

N-Queens

class Solution {
    private List<List<String>> res = new ArrayList<>();
    private List<List<String>> board = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        for(int i = 0; i < n; ++i){
            List<String> tmp = new ArrayList<>();
            for(int j = 0; j < n; ++j){
                tmp.add(".");
            }
            board.add(tmp);
        }
        backtracking(n, 0);
        return res;
    }

    private void backtracking(int n, int row){
        if(row == n){
            List<String> newBoard = toBoard(n);
            res.add(newBoard);
            return;
        }

        for(int i = 0; i < n; i++){
            if(isValid(row, i, n)){
                board.get(row).set(i, "Q");
                row++;
                backtracking(n, row);
                row--;
                board.get(row).set(i, ".");
            }
        }
    }

    private List<String> toBoard(int n){
        List<String> str = new ArrayList<>();
        for(int i = 0; i < n; ++i){
            String toAdd = "";
            for(int j = 0; j < n; ++j){
                if(board.get(i).get(j).equals("Q")){
                    toAdd += "Q";
                }else{
                    toAdd += ".";
                }
            }
            str.add(toAdd);
        }
        return str;
    }

    private boolean isValid(int row, int col, int n){
        for (int i = 0; i < row; i++) { 
            if (board.get(i).get(col).equals("Q")) {
                return false;
            }
        }

        for (int i = 0; i < row; i++) { 
            if (board.get(row).get(i).equals("Q")) {
                return false;
            }
        }
        
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board.get(i).get(j).equals("Q")) {
                return false;
            }
        }
 
        for(int i = row + 1, j = col + 1; i < n && j < n; i++, j++) {
            if (board.get(i).get(j).equals("Q")) {
                return false;
            }
        }

        for(int i = row + 1, j = col - 1; i < n && j >= 0; i++, j--) {
            if (board.get(i).get(j).equals("Q")) {
                return false;
            }
        }

        for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (board.get(i).get(j).equals("Q")) {
                return false;
            }
        }
        // System.out.println(Arrays.toString(board.toArray()));
        // System.out.println("row: " + row + " col: " + col);
        return true;
    }
}

Sudoku Solver

class Solution {

    private boolean isValid(int row, int col, char num, char[][] board){
        for (int i = 0; i < 9; ++i) {
            if (board[i][col] == num)
                return false;
        }
 
        for (int j = 0; j < 9; ++j) {
            if (board[row][j] == num)
                return false;
        }
    
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; ++i) {
            for (int j = startCol; j < startCol + 3; ++j) {
                if (board[i][j] == num)
                    return false;
            }
        }
        return true;
    }

    private boolean backtracking(char[][] board){
        for(int i = 0; i < 9; ++i){
            for(int j = 0; j < 9; ++j){
                if(board[i][j] == '.'){
                    for(char k = '1'; k <= '9'; ++k){
                        if(isValid(i, j, k, board)){
                            board[i][j] = k;
                            if(backtracking(board)) return true;
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }

    public void solveSudoku(char[][] board) {
        backtracking(board);
    }
}