代码随想录算法训练营第二十五天| 332.重新安排行程（可跳过） 51. N皇后（可跳过） 37. 解数独（可跳过）

 332.重新安排行程（可跳过）

难点：

1，解决死锁问题，我采用的是 selected，但是不会出现A->B->A这条信息

2，即使出现A-》B-》A，因为是有多条路径，所以无法找到合适的含有全部机场的路径

3，保证顺序

代码：

//机票信息 -》 一条遍历所有机场的路径
//步骤：
// 1，根据 start 压进去它的所有目的地信息
// 2， 目的地作为起始节点，进行遍历
// 3，如果这条路径到最后也没有遍历所有，那么就回复原装，开始遍历下一条路径
bool findItinerary_trackBack(map<string,map<string,int>>&tickets,int ticketNum, string start, vector<string>&result)
{
    if (result.size() == ticketNum +1)
    {
        return true;
    }

    for (pair<const string,int>& ticket : tickets[start])
    {
        if (ticket.second > 0)
        {
            result.push_back(ticket.first);
            ticket.second--;
            bool isComplete = findItinerary_trackBack(tickets, ticketNum, ticket.first, result);
            if (isComplete) return true;
            ticket.second++;
            result.pop_back();
        }

    }
    return false;
}

vector<string> findItinerary(vector<vector<string>>& tickets) {
    //需要tickets，转换成map《start,map》
    map<string, map<string, int>> tickets_map;
    for (auto ticket : tickets)
    {
        
        tickets_map[ticket[0]][ticket[1]]++;
    }

    vector<string>result;
    result.push_back("JFK");
    findItinerary_trackBack(tickets_map, tickets.size(), "JFK", result);
    return result;
}

 51. N皇后（可跳过）

难点：

1，判断是否可用

注意：

1，因为一行只能添加一个皇后，所以可以按照行进行遍历

2，只处理完当前行，就不处理了

代码：

bool IsQueenValid(const vector<string>&path, int curRow,int curCol)
{
    if (path.size() == 0)
        return true;

    //判断 col row--没有
    for (int i = curRow-1; i >= 0; i--)
    {
        if (path[i][curCol] == 'Q')
        {
            return false;
        }
    }

    //左斜向上没有Q
    for (int i = curRow-1, j = curCol-1; i >= 0&& j >= 0; i--, j--)
    {
        if (path[i][j] == 'Q')
            return false;
    }

    //右斜向上没有Q
    for (int i = curRow-1, j = curCol+1; i >=0 && j < path[0].size(); i--,j++)
    {
        if (path[i][j] == 'Q')
            return false;
    }

    return true;
}

void solveNQueen_trackBack(const vector<string>& nums,vector<string>&path, int curRow, vector<vector<string>>& result)
{
    if (curRow == nums.size())
    {
        result.push_back(path);
        return;
    }

    //对于每一行，先判断，我把节点放到这里行不行，如果不行continue
    for (int i = 0; i < nums[curRow].size(); i++)
    {
        if (IsQueenValid(path, curRow, i))
        {
            string cur_ = nums[curRow];
            cur_[i] = 'Q';
            path.push_back(cur_);
            solveNQueen_trackBack(nums, path, curRow + 1, result);
            path.pop_back();
        }
    }
}
vector<vector<string>> solveNQueens(int n) {
    vector<vector<string>> result;
    vector<string>path;
    vector<string> nums(n,string(n,'.'));
    solveNQueen_trackBack(nums, path, 0, result);
    return result;
}

 37. 解数独（可跳过） 

注意：

需要让每一行都填满，而不能填了一个数字就到下一行，这样的话会一直填不满

思路：

对每一个都进行排序，然后在判断所有的节点，因为有当前节点是否是.的判断，所以直接迭代是没有问题的

代码：

bool isValid_sudoku(vector<vector<char>>& board,int row, int col, char val)
{
    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++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val) {
                return false;
            }
        }
    }
    return true;
}

//需要保证，每一层都填满了
// false: 就是这一层 还没填完，就到下一层了，这是不可以的
bool solveSudoku_trackBack(vector<vector<char>>& board)
{
    for (int curRow = 0; curRow < board.size(); curRow++)
    {
        for (int i = 0; i < board[0].size(); i++)
        {
            if (board[curRow][i] == '.')
            {
                for (char num = '1'; num <= '9'; num++)
                {
                    if (isValid_sudoku(board, curRow, i, num))
                    {
                        board[curRow][i] = num;
                        bool isComplete = solveSudoku_trackBack(board);
                        if (isComplete) return true;
                        board[curRow][i] = '.';
                    }
                }
                return false;
            }
        }

    }

    return true;
}

//难点
//怎么去回溯，什么时候设置终止条件
void solveSudoku(vector<vector<char>>& board) {
    solveSudoku_trackBack(board);
}