算法训练营day30_回溯算法（3.2）

算法训练营day30_回溯算法（3.2）

332.重新安排行程

用时将近1s内存300MB可还行；不过也算是自己做出来了；

这道题太搞了，思路三个历程吧算是；

刚开始想着每次找字典序最小的，但是有可能最后用不完所有票就到终点了（可能这张票的终点就是整个旅程的终点）；

后来想着全部的方案都存下来，存到二维ans里，排序输出最小的，严重超时，只过了十几个测例；

最后想折中一下，每次都把A能到的B放到一个vector里，排一下顺序，这样可以保证先走的是字典序小的，如果走不通还能走字典序稍大点的，找到一个可行路径就返回；

typedef pair<string,int> PII;
class Solution {
public:
    vector<string> path;
    bool dfs(int cnt,vector<vector<string>> tickets,vector<bool> st,string last){
        if(cnt>=tickets.size()){
            return true;
        };
        vector<PII> V;
        for(int i=0;i<tickets.size();i++){
            if(st[i]) continue;
            string a=tickets[i][0],b=tickets[i][1];
            if(a!=last) continue;
            V.push_back({b,i});
        }
        if(!V.size()) return false;
        sort(V.begin(),V.end());
        for(auto i:V){
            string str=i.first;
            int sec=i.second;
            path.push_back(str);
            st[sec]=true;
            if(dfs(cnt+1,tickets,st,str)) return true;
            path.pop_back();
            st[sec]=false;         
        }
        return false;
    }
    
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        path.clear();
        vector<bool> st(tickets.size(),false);
        path.push_back("JFK");
        dfs(0,tickets,st,"JFK");
        return path;   
    }
};

51.N皇后

之前做过，第u个位置放i转化为第u行i列放皇后；

标记数组有四个，行，列，左对角，右对角；

刚开始没审题，让找到所有的情况，注意身体啊！读懂题之后还要读懂输入输出，样例；

const int N=10;
class Solution {
public:
    vector<vector<string>> ans;
    void dfs(int u,int n,vector<bool> row,vector<bool> col,vector<bool> lst,vector<bool> rst,vector<string> path){
        if(u>=n){
            ans.push_back(path);
            return;
        }

        for(int i=0;i<n;i++){
            if(row[u]||col[i]||lst[u-i+N]||rst[u+i]) continue;
            path[u][i]='Q';
            row[u]=col[i]=lst[u-i+N]=rst[u+i]=true;
            dfs(u+1,n,row,col,lst,rst,path);
            path[u][i]='.';
            row[u]=col[i]=lst[u-i+N]=rst[u+i]=false;
        }    
    }
    
    vector<vector<string>> solveNQueens(int n) {
        ans.clear();
        vector<bool> row(20,false);
        vector<bool> col(20,false);
        vector<bool> lst(20,false);
        vector<bool> rst(20,false);
        vector<string> path(n,string(n,'.'));//string是构造一个字符串；因为容器里放的是字符串
        dfs(0,n,row,col,lst,rst,path);
        return ans;
    }
};

37.解数独

这道题纯纯破大防，脑子抽了忘记参数引用了，de了一个多小时；

找到一个方案即可，返回值用bool；

相比于n皇后，它的每一行每一列都得放个数字，n皇后是每一行挑一列放，故这里是需要两层循环的，外层i，内层

j；而n皇后只需要dfs参数里放i，一层循环j；

判断是否能放也与n皇后不同，n皇后可以用标记数组来标记行，列，对角线，而这里显然不能，因为不再是每一行一列只有一个；用最暴力的，for循环看一下同行有无相同，同列有无相同；

棋盘定位九宫格，挺巧妙的，行列分别/3把余数舍掉，再*3得到所属棋盘的左上

class Solution {
public:
    bool check(int row,int col,char x,vector<vector<char>> board){
        for(int i=0;i<9;i++){
            if(board[row][i]==x) return false;
            if(board[i][col]==x) return false;
        }
        int a=(row/3)*3;
        int b=(col/3)*3;
        for(int i=a;i<a+3;i++){
            for(int j=b;j<b+3;j++){
                if(board[i][j]==x) return false;
            }
        }
        return true;
    }

     bool dfs(vector<vector<char>>& board){
        for(int i=0;i<board.size();i++){
             for(int j=0;j<board[0].size();j++){
                    if(board[i][j]!='.') continue;
                     for(char x='1';x<='9';x++){
                         if(check(i,j,x,board)){
                             board[i][j]=x;
                             if(dfs(board)) return true;
                             board[i][j]='.';
                         }
                     }  
                    return false;             
             }        
        }
        return true;
     }
    void solveSudoku(vector<vector<char>>& board) {
        dfs(board);
    }
};