Leecode 37. 解数独 dfs+回溯

自信的小螺丝钉

已于 2022-04-09 23:32:14 修改

阅读量293

点赞数

分类专栏： Leetcode 文章标签： c++ leetcode dfs 深度优先

于 2022-04-09 22:43:48 首次发布

本文链接：https://blog.csdn.net/qq_45791939/article/details/124069862

版权

Leetcode 专栏收录该内容

330 篇文章 0 订阅

订阅专栏

这篇博客介绍了两种不同的C++解法来解决数独问题，包括使用数组存储和位运算优化。这两种解法都通过递归深度优先搜索（DFS）策略，结合行、列和宫的限制来填充空格。博客内容详细展示了如何利用位运算提高空间效率，同时提供了完整的代码实现。

摘要由CSDN通过智能技术生成

原题链接：Leecode 37. 解数独
在这里插入图片描述

巧用pair<int,int>存储空格的位置：

解法一：数组存储

class Solution {
public:
    int row[10][10];//行
    int col[10][10];//列
    int box[10][10];//宫
    vector<pair<int, int>> t;
    bool valid=false;
    void dfs(vector<vector<char>>& board,int num)
    {
        if(num==t.size())
        {
            valid=true;
            return ;
        }
        int i=t[num].first;
        int j=t[num].second;
        for(int k=1;k<=9;k++)
        {
            if(!valid)
            {
                int index=(j/3)*3+i/3; 
                if(!row[i][k] && !col[j][k] && !box[index][k])
                {
                    row[i][k]=col[j][k]=box[index][k]=1;
                    board[i][j]=k+'0';
                    dfs(board,num+1);
                    row[i][k]=col[j][k]=box[index][k]=0;
                }
            }
        }
    }
    void solveSudoku(vector<vector<char>>& board) {
        int sum=0;
        for(int i=0;i<9;i++)
        {
            for(int j=0;j<9;j++)
            {
                int index=(j/3)*3+i/3; //该数在哪一个宫中
                if(board[i][j]=='.')
                {
                    t.push_back({i,j});
                }
                else 
                {
                    int tmp=board[i][j]-'0';
                    row[i][tmp]=1;
                    col[j][tmp]=1;
                    box[index][tmp]=1;
                }
            }
        }
        dfs(board,0);
    }
};

解法二：位运算

class Solution {
public:
    int row[10];//行
    int col[10];//列
    int box[10];//宫
    vector<pair<int, int>> t;
    bool valid=false;
    void dfs(vector<vector<char>>& board,int num)
    {
        if(num==t.size())
        {
            valid=true;
            return ;
        }
        int i=t[num].first;
        int j=t[num].second;
        for(int k=1;k<=9;k++)
        {
            if(!valid)
            {
                int index=(j/3)*3+i/3; 
                if(!((row[i]>>k)&1) && !((col[j]>>k)&1) && !((box[index]>>k)&1))
                {
                    row[i]|=(1<<k);
                    col[j]|=(1<<k);
                    box[index]|=(1<<k);
                    board[i][j]=k+'0';
                    dfs(board,num+1);
                    row[i]&=~(1<<k);
                    col[j]&=~(1<<k);
                    box[index]&=~(1<<k);
                }
            }
        }
    }
    void solveSudoku(vector<vector<char>>& board) {
        int sum=0;
        for(int i=0;i<9;i++)
        {
            for(int j=0;j<9;j++)
            {
                int index=(j/3)*3+i/3; //该数在哪一个宫中
                if(board[i][j]=='.')
                {
                    t.push_back({i,j});
                }
                else 
                {
                    int tmp=board[i][j]-'0';
                    row[i]|=(1<<tmp);
                    col[j]|=(1<<tmp);
                    box[index]|=(1<<tmp);
                }
            }
        }
        dfs(board,0);
    }
};