算法训练day24 | php | 332.重新安排行程 ， 51. N皇后 ， 37. 解数独 ，总结

一、力扣题332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

• 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

示例 1：

输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]

示例 2：

输入：tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"] ，但是它字典排序更大更靠后。

提示：

• 1 <= tickets.length <= 300
• tickets[i].length == 2
• fromi.length == 3
• toi.length == 3
• fromi 和 toi 由大写英文字母组成
• fromi != toi

        使用map数组，将行程中的出发点作为map数组的键名，键值为降落点，因为同一出发点可能有多个降落点，所以map数组是一个二维数组。

        又因题目只需要按字典排序最小的行程组合，所以不需要遍历得出所有合理的行程组合，把同一出发点对应的多个降落点按照字典排序升序排列，那么遍历得到的第一个合理行程组合，一定是按字典排序最小的行程组合，此时可直接中断循环，返回结果。

class Solution {
    private $count = 0;
    private $result = [];
    /**
     * @param String[][] $tickets
     * @return String[]
     */
    function findItinerary($tickets) {
        $list = [];
        foreach($tickets as $ticket) {
            $list[$ticket[0]][] = $ticket[1];    //转化为map数组
        }
        foreach($list as $key => $val) {
            sort($list[$key]);            //对二维数组中的降落点进行升序排列
        }
        $from = "JFK";
        $path = [$from];
        $this->count = count($tickets);
        $this->backtracking($list, $from, $path);
        return $this->result;
    }

    function backtracking($list, $from, $path) {
        if(count($path) == $this->count + 1) {    //当得到合理的行程组合是，直接return
            $this->result = $path;
            return true;
        }
        if($list[$from] == []) {
            return false;
        }
        foreach($list[$from] as $key => $val) {
            $path[] = $val;
            unset($list[$from][$key]);
            if($this->backtracking($list, $val, $path)) {    //获取到true的信息，直接return
                return true;
            };
            $list[$from][$key] = $val;
            array_pop($path);
        }
    }
}

二、力扣题51. N 皇后

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

示例 1：

输入：n = 4
输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

示例 2：

输入：n = 1
输出：[["Q"]]

提示：

• 1 <= n <= 9

         由题意可知，皇后与皇后之间不能在同一行或同一列或同一斜线上。所以每一行都只放一个皇后，这样就可以转换为树形结构了。将回溯遍历与 "判断某个位置是否可以放置皇后" 分成两个函数，第一层遍历第一行的n个位置，若遍历到的位置可以放置，则进入下一层遍历第二行的位置。而层数是固定是 n 层的，当进入第 n + 1层时，说明当前已获取到解法，可以中断了。

        除了遍历的逻辑外，来看看 "判断某个位置是否可以放置皇后"这个函数，因为皇后是从上往下放置的，所以当遍历到第 i 层是，第 i 层以下 即 大于 i 的层数是一定没有皇后的，所以我们只需要遍历判断小于第 i 层的每一层中是否有与当前位置同列，同行，同斜线的皇后，同斜线需要查看45度角和135度角两个方向。

        最后，还要把获得的解法，转化成题目要求的答案形式。

class Solution {
    private $n = 0;
    private $result = [];
    /**
     * @param Integer $n
     * @return String[][]
     */
    function solveNQueens($n) {
        $this->n = $n;
        $this->backtracking([], 0);
        return $this->result;
    }

    function backtracking($path, $cur) {
        if($cur == $this->n) {
            $res = [];
            foreach($path as $arr) {
                $str = '';
                for($i = 0; $i < $this->n; $i++) {
                    if(isset($arr[$i])) {
                        $str .= $arr[$i];
                    } else {
                        $str .= ".";
                    }
                }
                $res[] = $str;
            }
            $this->result[] = $res;
        }
        
        for($i = 0; $i < $this->n; $i++) {
            if($this->isValid($cur, $i, $path)) {
                $path[$cur][$i] = 'Q';
                $this->backtracking($path, $cur + 1);
            }
            $path[$cur][$i] = '.';
        }
    }

    function isValid($row, $col, $path) {

        //检查列
        for($i = 0; $i < $row; $i++) {
            if($path[$i][$col] == 'Q') {
                return false;
            }
        }

        //检查45度角
        for($i = $row - 1, $j = $col - 1; $i >= 0 && $j >= 0; $i--, $j--) {
            if($path[$i][$j] == 'Q') {
                return false;
            }
        }

        //检查135度角
        for($i = $row - 1, $j = $col + 1; $i >= 0 && $j <= $this->n; $i--, $j++) {
            if($path[$i][$j] == 'Q') {
                return false;
            }
        }

        return true;
    }
}

三、力扣题37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：
board = 
[["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"]]
输出：
[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：

提示：

• board.length == 9
• board[i].length == 9
• board[i][j] 是一位数字或者 '.'
• 题目数据 保证 输入数独仅有一个解

         这道题我一开始一直在死磕，不理解为什么一定要用二维递归，认为递归中用一个for循环也可以。最后才理解了，这道题和 "n 皇后" 那道题是不一样的，n 皇后是在每一行中为皇后选取一个位置，遍历的次数只是列数 n 次。但本题，在每一行中，是要为每一行中的每一个位置在 [1, 9]中选取一个数，遍历次数是 n * n 次，所以自然要用两层for循环。

        其中如果遍历到的位置已经有数字了，就可以直接跳过。

        而判断函数中，不仅要判断同行同列是否有相同数字，还要判断九宫格。

class Solution {
    private $result = [];
    /**
     * @param String[][] $board
     * @return NULL
     */
    function solveSudoku(&$board) {
        $this->backtracking($board);
    }

    function backtracking(&$board) {
        for($j = 0; $j < 9; $j++) {
            for($i = 0; $i < 9; $i++) {
                if($board[$j][$i] != ".") {
                    continue;
                }
                for($val = 1; $val <= 9; $val++) {
                    if($this->isValid($j, $i, $board, $val)) {
                        $board[$j][$i] = (string)$val;
                        if($this->backtracking($board)) return true;
                    }
                    $board[$j][$i] = '.';
                }
                return false;
            }
        }
        return true;
    }

    function isValid($row, $col, $board, $val) {

        //判断同行
        for($i = 0; $i < 9; $i++) {
            if($board[$row][$i] == $val) {
                return false;
            }
        }

        //判断同列
        for($i = 0; $i < 9; $i++) {
            if($board[$i][$col] == $val) {
                return false;
            }
        }

        //判断九宫格
        $row = intval($row / 3) * 3;
        $col = intval($col / 3) * 3;
        for($i = 0; $i < 3; $i++) {
            for($j = 0; $j < 3; $j++) {
                if($board[$row + $i][$col + $j] == $val) {
                    return false;
                }
            }
        }

        return true;
    }
}

四、总结

        做完这几天的回溯题后，深深感觉到了回溯模板的好用之处，基本所有的回溯题都是这个套路。

        其中有几种变体：

        1、最简单的一种：路径数组 path 存放元素的方式和时机的变化。例如在切割字符串的题目中遍历的是切割点，所以需要切割出一部分字符串放入path。还有子集问题中，在每次遍历时都需要放入一次path。

        2、树层去重。在基础的回溯上，添加了树层去重的要求，同一树层中，不能选取重复的元素。例如 "组合总和II" 问题，"子集II" 问题。可以直接判断，也可以使用used数组。

        3、树枝去重。例如全排列问题，在每一层都是从 0 开始遍历，所以在一条树枝上，需要标记已经放入的元素，这样才不会放入重复的元素。可以使用uset数组，也可以用map数组。

        4、二维递归。很特殊的一种类型，在回溯函数中使用了二层for循环。

        而应对的方法有两个：

        1、转化为树形结构。这个非常有用，基本所有回溯问题都可以转化为 n 叉树，而转化后，我们就可以按照二叉树的结构来写回溯套路了。

        2、剪枝操作。有些解法如果不剪枝就会超时。例如上面的重新安排行程这道题，我一开始是先遍历得出所有解法，再把这些解法排序得出字典排序最小的解法，最后超时了。而题解是从一开始就把这些降落点排序好，最后遍历获得排序最小的解法就直接return了。需要灵活应对。