leetcode0916

79、单词搜索

同样是使用之前的回溯法，不过这次是修改标志位，代码如下（使用递归实现）：

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        if(board.empty())return false;
        int m=board.size(),n=board[0].size();
        vector<vector<bool>>visited(m,vector<bool>(n,false));
        bool find=false;
        for(int i=0;i<m;++i){
            for(int j=0;j<n;++j){
                backtracking(i,j,board,word,find,visited,0);
            }
        }
        return find;
    }

    void backtracking(int i,int j,vector<vector<char>>&board,string&word,bool &find,vector<vector<bool>>&visited,int pos){
        if(i<0||i>=board.size()||j<0||j>=board[0].size()){
            return;
        }
        if(visited[i][j]||find||board[i][j]!=word[pos]){
            return;
        }
        if(pos==word.size()-1){
            find=true;
            return;
        }
        visited[i][j]=true;

        backtracking(i+1,j,board,word,find,visited,pos+1);
        backtracking(i-1,j,board,word,find,visited,pos+1);
        backtracking(i,j+1,board,word,find,visited,pos+1);
        backtracking(i,j-1,board,word,find,visited,pos+1);
        visited[i][j]=false;
    }
};

51、N-Queens

题目描述：

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> ans;//初始化答案
        if(n==0){
            return ans;//异常情况检测
        }
        vector<string> board(n,string(n,'.'));
        vector<bool> column(n,false),ldiag(2*n-1,false),rdiag(2*n-1,false);//状态矩阵：列、左对角、右斜对角
        backtracking(ans,board,column,ldiag,rdiag,0,n);
        return ans;
    }

    void backtracking(vector<vector<string>>&ans,vector<string> &board,vector<bool> &column,vector<bool> &ldiag,vector<bool> &rdiag,int row,int n){
        if(row==n){
            ans.push_back(board);//表示已经到最后一行了，表示已经完成搜索过程，加入答案
            return;
        }

        for(int i=0;i<n;++i){//按行搜索
            if(column[i]||ldiag[n-row+i-1]||rdiag[row+i+1]){
                continue;
            }
            //修改当前节点状态
            board[row][i]='Q';
            column[i]=ldiag[n-row+i-1]=rdiag[row+i+1]=true;
            //递归子节点
            backtracking(ans,board,column,ldiag,rdiag,row+1,n);
            //回改当前节点的状态
            board[row][i]='.';
            column[i]=ldiag[n-row+i-1]=rdiag[row+i+1]=false;
        }
    }
};

广度优先搜索

广度优先搜索（BFS）不同于深度优先搜索，是一层层进行搜索的，因此需要用先入先出的队列，由于是按层次进行遍历，广度优先搜索时按照“广”的方向进行遍历的，所以常常用来处理最短路径的问题。
深度优先和广度优先搜索都可以处理可达性的问题，即从一个节点开始是否能达到另一个节点。