leetcodeDFS题型汇总

深度优先搜索

void dfs(){
	if('递归到最远位置'){
		'需要执行的函数体'
        return;
	}
    for(;;;){
        if('条件'){
            '执行函数';
            dfs();
            '考虑是否将上面函数复位';
        }
    }
}

547. 省份数量

class Solution {
private:
    vector<bool> isvisited;
    void dfs(vector<vector<int>>& isConnected ,int x){
        for(int i = 0;i<isConnected.size() ;++i){
            if(i !=x && isConnected[x][i] &&!isvisited[i]){
                isvisited[i] = true;
                dfs(isConnected,i);
            }
        }
        return;
    }
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size();
        isvisited.resize(n,0);
        int res = 0;
        for(int i = 0;i< n;++i){
            if(!isvisited[i]){
                isvisited[i] = true;
                dfs(isConnected,i);
                res++;
            }
        }
        return res;
    }
};

46. 全排列

class Solution {
private:
    vector<vector<int>>ans;
    vector<int>temp;
    vector<int>isvisted;
    void dfs(vector<int>& nums,int x ,int n){
        if(x == n){
            ans.push_back(temp);
            return;
        }
        for(int i = 0;i< n;++i){
            if(!isvisted[i]){
                isvisted[i] = 1;
                temp.push_back(nums[i]);
                dfs(nums,x+1,n);
                isvisted[i] = 0;
                temp.pop_back();
            }
        }
    }

public:
    vector<vector<int>> permute(vector<int>& nums) {
        int n = nums.size();
        isvisted.resize(n,0);
        dfs(nums,0,n);
        return ans;
    }
};

51. N 皇后

class Solution {
public:
    static const int M =20;
    int row[M], col[M], dg[M] ,udg[M];
    vector<string> a;
    vector<vector<string>> res;

    vector<vector<string>> solveNQueens(int n) {
        a.resize(n,string(n,'.'));
        dfs(0,n);
        return res;
    }

    void dfs(int u ,int n){
        if(u == n){
            res.push_back(a);
        }
        for(int i = 0;i<n ;++i){
            if(!row[u]&& !col[i] &&!dg[u-i+n]&&!udg[i+u]){
                a[u][i] = 'Q';
                row[u] = col[i] = dg[u-i+n] = udg[i+u] = 1;
                dfs(u+1,n);
                a[u][i] = '.';
                row[u] = col[i] = dg[u-i+n] = udg[i+u] = 0;
            }
        }
    }
};

210. 课程表 II（拓扑排序）

错误解法（无法判断出是否有环）

class Solution {
private:
    vector<int> isvisited;
    stack<int> st;
    void dfs(vector<vector<int>>& prerequisites , int pos){
        for(int i = 0 ;i< prerequisites.size() ;++i){
            int y = prerequisites[i][0];
            int x = prerequisites[i][1];
            if(x == pos && !isvisited[y]){
                isvisited[y] = 1;
                dfs(prerequisites,y);
                st.push(y);
            }
        }
    }
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> res;
        int n = prerequisites.size();
        isvisited.resize(numCourses,0);
        for(int i = 0;i<numCourses ;++i){
            if(!isvisited[i]){
                dfs(prerequisites,i);
                isvisited[i] = 1;
            }
        }
        for(int i = 0;i<numCourses ;++i){
            if(!isvisited[i]){
                st.push(i);
            }
        }
        if(numCourses != st.size()){
            return res;
        }
        while(!st.empty()){
            res.push_back(st.top());
            st.pop();
        }
        return res;
    }
};

需要增加一个操作来判断是否存在环

//深度优先算法
//关键在于如何判断是否存在环，将当前的访问状态设置为三类，访问中、访问前、访问后。当一个数组已经访问完成后仍然处于访问中则可以判断存在环。
//增加一个额外空间，将有向图的关系一一保存，这样在dfs中可以有效减枝
class Solution {
private:
    vector<vector<int>> edges;
    vector<int> isvisited;
    vector<int> res;
    bool vaild = true;
public:
    void dfs(int u){
        isvisited[u] = 1;
        for(int v :edges[u]){
            if(isvisited[v] == 0){
                dfs(v);
                if(!vaild){
                    return;
                }
            }else if(isvisited[v] == 1){
                vaild = false;
                return;
            }
        }
        isvisited[u] = 2;
        res.push_back(u);
    }
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        isvisited.resize(numCourses,0);
        for(auto a: prerequisites){
            edges[a[1]].push_back(a[0]);
        }
        for(int i = 0;i< numCourses&&vaild ;++i){
            if(!isvisited[i]){
                dfs(i);
            }
        }
        if(!vaild){
            return {};
        }else{
            reverse(res.begin(),res.end());
            return res;
        }
    }
};

//广度优先算法
class Solution {
private:
    vector<vector<int>> edges;
    vector<int> indeg;
    vector<int> res;
public:
    vecto