代码随想录算法训练营第30天|332.重新安排行程、51.N皇后、37.解数独

332.重新安排行程

题目链接：332.重新安排行程（困难）
题目描述：

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

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

例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前。
假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

解题思路：

1. 个人觉得最难的是构造出unordered_map<string,map<string,int>> targets;这个数据结构。

class Solution {
public:
    
    vector<string>result;
    unordered_map<string,map<string,int>> targets;//记录起始地-到达地的次数
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        result.push_back("JFK");
        for(const vector<string>& ticket:tickets)
        {
            targets[ticket[0]][ticket[1]]++;//将门票的每一个都存在target中
        }
        backtracking(result,tickets.size());
        return result;

    }
    bool backtracking(vector<string>& result,int num)
    {
        if(result.size()==num+1)//如果结果里的值等于门票数+1，说明已经最后了
            return true;
        for(pair<const string,int>&target:targets[result[result.size()-1]]) //获得结果中最后一个目的地，作为起始地
        {
            if(target.second>0)//表明是存在该目的地的
            {
               result.push_back(target.first);
               target.second--;
               if(backtracking(result,num)) return true;
               target.second++;
               result.pop_back();
            }

        }
        return false;
    }
    
};

51. N皇后

题目链接：N皇后
题目描述：

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

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

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

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

解题思路：

1. 首先我们需要判断棋子是否符合要求，比如给定行和列，以及给定的棋盘布置（主要判断的是当前下的一个字符是否符合要求）。
   按照要求是，不能同行，不能同列，不能在斜线上。同行比较好比较（由于是在回溯中，因此，在同一层上不会有重复的，不需要判断），同列仅仅只需固定住列，判断不同行上面是否有皇后即可。斜线上比较复杂。分两种，一种从右下到左上，另一种从左下到右上。

 bool isValid(vector<string>&chessboard,int row,int col,int n)
    {
        for(int i=0;i<row;i++) //检查列
        {
            if(chessboard[i][col]=='Q') return false;
        }
        //副对角线
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)
        {
            if(chessboard[i][j]=='Q') return false;
        }
        //主对角线
        for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) 
        {
            if (chessboard[i][j] == 'Q') return false;
        
        }
        return true;
    }

2. 知道了如何判断后，采用回溯三部曲，还是比较能够清楚的简答了。

class Solution {
public:
    vector<vector<string>>result;
    
    vector<vector<string>> solveNQueens(int n) {
        vector<string>chessboard(n,string(n,'.'));
        backtracking(n,0,chessboard);
        return result;

    }
    void backtracking(int n,int row,vector<string>& chessboard)
    {
        if(row==n){//如果遍历到了最后一层，说明可以，放入答案中
            result.push_back(chessboard);
            return ;
        }
        for(int col=0;col<n;col++)
        {
            if(isValid(chessboard,row,col,n))
            {
                chessboard[row][col]='Q';
                backtracking(n,row+1,chessboard);
                chessboard[row][col]='.';
            }
        }
    }
    bool isValid(vector<string>&chessboard,int row,int col,int n)
    {
        for(int i=0;i<row;i++) //检查列
        {
            if(chessboard[i][col]=='Q') return false;
        }
        //检查135度角
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)
        {
            if(chessboard[i][j]=='Q') return false;
        }
        for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) 
        {
            if (chessboard[i][j] == 'Q') return false;
        
        }
        return true;
    }
};

37.解数独

题目链接：37.解数独
题目描述：

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

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

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);

    }
    bool isValid(int row,int col,char val,vector<vector<char>>& board)//判断是否合法
    {
        for(int i=0;i<9;i++)
        {
            if(board[row][i]==val) return false;//如果行里有重复
        }
        for(int j=0;j<9;j++)
        {
            if(board[j][col]==val)  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] == val)  return false;
        }
        return true;
    }
    bool backtracking(vector<vector<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;
       
    }
};

注意：回溯全部结束了，周末找时间再这个底下做个简单的总结回顾。