【Leetcode】dfs深度优先搜索

46. 全排列

leetcode 46

class Solution {
public:
    vector<vector<int>> ans;

    // 判断当前数字是否被使用过（基于原始数列没有重复元素）
    bool isValid(vector<int>& res, int num) {
        for(int& n : res) {
            if(n == num) return false;
        }
        return true;
    }

    void dfs(vector<int>& nums, vector<int>& res){
        // 找到一组排列，加入ans，返回
        if(res.size() == nums.size()){
            ans.push_back(res);
            return;
        }
        // 遍历当前位置所有可能取值
        for(int i = 0; i < nums.size(); i++){
            if(!isValid(res, nums[i])) continue;
            res.push_back(nums[i]);
            dfs(nums, res);
            res.pop_back();  // 回退
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        // 声明一个存储可能排列的容器
        vector<int> res;
        // 因为所有可能性都要被找出，所以dfs为void型函数，需要迭代各种可能性
        dfs(nums, res);
        return ans;
    }
};

47. 全排列II

leetcode 47

class Solution {
public:
    vector<vector<int>> ans;

    void dfs(vector<int>& nums, vector<int>& res, vector<int>& visited) {
        // 找到一组排列，加入ans，返回
        if(res.size() == nums.size()) {
            ans.push_back(res);
            return;
        }
        // 遍历当前位置所有可能取值
        for(int i = 0; i < nums.size(); i++) {
            if(visited[i]) continue;
            res.push_back(nums[i]);
            visited[i] = 1;
            dfs(nums, res, visited);
            res.pop_back(); // 回退
            visited[i] = 0; // 回退
            while(i + 1 < nums.size() && nums[i] == nums[i+1]) i++; // 不断跳过重复的元素
        }
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end()); // 先排序！使得重复的元素紧挨在一起
        vector<int> res;
        vector<int> visited(nums.size()); // 记录访问过的元素
        // 因为所有可能性都要被找出，所以dfs为void型函数，需要迭代各种可能性
        dfs(nums, res, visited);
        return ans;
    }
};

37. 解数独

leetcode 37

class Solution {
public:
    // 判断当前位置（i,j）能否放置值ch
    bool isValid(const vector<vector<char>>& board, char ch, int i, int j) {
        for(int k = 0; k < 9; k++) {
            if(board[k][j] == ch) return false; // 列
            if(board[i][k] == ch) return false; // 行
            if(board[(i/3)*3 + k/3][(j/3)*3 + k%3] == ch) return false; // 3x3方格
        }
        return true;
    }

    bool dfs(vector<vector<char>>& board, int i, int j) {
        int n = 9;
        // 搜索完当前行跳到下一行第一位
        if(j == 9) {
            return dfs(board, i + 1, 0);
        }
        // 搜索完所有行，结束，返回true
        if(i == 9) {
            return true;
        }
        // 如果当前位置已经有数字，则跳过
        if(board[i][j] != '.') {
            return dfs(board, i, j + 1);
        }
        // 对当前位置（i,j）遍历1~9
        for(char ch = '1'; ch <= '9'; ch++) {
            if(!isValid(board, ch, i, j)) continue;
            board[i][j] = ch;
            if(dfs(board, i, j + 1)) return true; // 找到直接退出
            board[i][j] = '.';
        }
        return false;
    }

    void solveSudoku(vector<vector<char>>& board) {
        // 因为只有一个解，所以dfs为bool类型函数，找到直接退出，无需遍历其他可能
        dfs(board, 0, 0); 
        return;
    }
};

51. N皇后

leetcode 51

class Solution {
public:
    vector<vector<string>> ans;

    // 判断当前位置能否放置皇后
    bool isValid(vector<string>& map, int i, int j, int n) {
        for(int k = 0; k < n; k++) {
            // 判断水平和竖直方向
            if(map[i][k] == 'Q') return false;
            if(map[k][j] == 'Q') return false;
            // 判断对角线的四个方向
            if(k <= i && k <= j && map[i-k][j-k] == 'Q') return false;
            if(k + i < n && k + j < n && map[i+k][j+k] == 'Q') return false;
            if(k <= i && k + j < n && map[i-k][j+k] == 'Q') return false;
            if(k + i < n && k <= j && map[i+k][j-k] == 'Q') return false;
        }
        return true;
    }

    void dfs(vector<string>& map, int i, int n) {
        // 最后一行搜索完成后返回
        if(i == n) {
            ans.push_back(map);
            return;
        }
        // 对当前行i的每一个位置搜索
        for(int j = 0; j < n; j++) {
            if(!isValid(map, i, j, n)) continue;
            map[i][j] = 'Q';
            dfs(map, i+1, n);
            map[i][j] = '.'; // 回退
        }
        return;
    }

    vector<vector<string>> solveNQueens(int n) {
        // 初始化一个棋盘格
        vector<string> map(n);
        string init(n, '.');
        for(int i = 0; i < n; i++) map[i] = init; 
        // 因为所有可能性都要被找出，所以dfs为void型函数，需要迭代各种可能性
        dfs(map, 0, n);
        return ans;
    }
};