37.数独求解

Sudoku Solver

问题描述:

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character ‘.’.

You may assume that there will be only one unique solution.
问题
A sudoku puzzle…
解
…and its solution numbers marked in red.

知识补充:

学会灵活使用结构体,结构体也可以作为元素放入栈和队列中。这样的话就有多种存储数据的方法了

char型相互转化为int型

char c = '1';
int i;
i = (int)c;//强制转换
i = c-'0';//差值即为所要转换数字
c = (char)i;//强制转换
c = char(48+i);//通过差值转换

参考答案:

class Solution {
        bool check(vector<vector<char>> &board, int i, int j, char val)
        {
            int row = i - i%3, column = j - j%3;
            for(int x=0; x<9; x++) if(board[x][j] == val) return false;
            for(int y=0; y<9; y++) if(board[i][y] == val) return false;
            for(int x=0; x<3; x++)
            for(int y=0; y<3; y++)
                if(board[row+x][column+y] == val) return false;
            return true;
        }
        bool solveSudoku(vector<vector<char>> &board, int i, int j)
        {
            if(i==9) return true;
            if(j==9) return solveSudoku(board, i+1, 0);
            if(board[i][j] != '.') return solveSudoku(board, i, j+1);

            for(char c='1'; c<='9'; c++)
            {
                if(check(board, i, j, c))
                {
                    board[i][j] = c;
                    if(solveSudoku(board, i, j+1)) return true;
                    board[i][j] = '.';
                }
            }

            return false;
        }    
public:
    void solveSudoku(vector<vector<char>>& board) {
        solveSudoku(board, 0, 0);
    }
};

性能:

这里写图片描述

参考答案:

class ValidMoves {
private:
    int num_valid;
    int blocked_count[9];

public:
    ValidMoves()
        : num_valid(9), blocked_count {0, 0, 0, 0, 0, 0, 0, 0, 0}
    {}

    inline int valid() const { return num_valid; }

    inline void block(int move) {
        mod(move, 1);
    }

    inline void unblock(int move) {
        mod(move, -1);
    }

    void mod(int move, int d) {
        if(blocked_count[move] == 0) {
            num_valid--;
        }
        blocked_count[move] += d;
        if(blocked_count[move] == 0) {
            num_valid++;
        }
    }

    inline bool isValid(int move) const { return blocked_count[move] == 0; }
};

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        vector<vector<ValidMoves>> validMoves (9, vector<ValidMoves>(9));
        for(int i1=0; i1<9; i1++) {
            for(int i2=0; i2<9; i2++) {
                if(board[i1][i2] != '.') {
                    makeMove(board, validMoves, i1, i2, board[i1][i2] - '1');
                }
            }
        }

        _solveSudoku(board, validMoves);
    }

private:
    void makeMove(vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves, int i1, int i2, int move) {
        board[i1][i2] = (char)(move + '1');
        modRow(board, validMoves, i1, move, 1);
        modCol(board, validMoves, i2, move, 1);
        modBlock(board, validMoves, i1/3, i2/3, move, 1);
    }

    void unMakeMove(vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves, int i1, int i2, int move) {
        modBlock(board, validMoves, i1/3, i2/3, move, -1);
        modCol(board, validMoves, i2, move, -1);
        modRow(board, validMoves, i1, move, -1);
        board[i1][i2] = '.';
    }

    inline void modRow(const vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves, int i1, int move, int d) {
        for(int i2=0; i2<9; i2++) {
            if(board[i1][i2] != '.') {
                continue;
            }
            validMoves[i1][i2].mod(move, d);
        }
    }

    inline void modCol(const vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves, int i2, int move, int d) {
        for(int i1=0; i1<9; i1++) {
            if(board[i1][i2] != '.') {
                continue;
            }
            validMoves[i1][i2].mod(move, d);
        }
    }

    inline void modBlock(const vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves, int bi1, int bi2, int move, int d) {
        for(int i1=0; i1<3; i1++) {
            for(int i2=0; i2<3; i2++) {
                int i1_ = i1 + bi1*3, i2_ = i2 + bi2*3;
                if(board[i1_][i2_] != '.') {
                    continue;
                }
                validMoves[i1_][i2_].mod(move, d);
            }
        }
    }

    bool _solveSudoku(vector<vector<char>>& board, vector<vector<ValidMoves>>& validMoves) {
        int most_constrained_count = INT_MAX, most_constrained_i1, most_constrained_i2;        
        for(int i1=0; i1<9; i1++) {
            for(int i2=0; i2<9; i2++) {
                if(board[i1][i2] == '.' && validMoves[i1][i2].valid() < most_constrained_count) {
                    most_constrained_count = validMoves[i1][i2].valid();
                    most_constrained_i1 = i1;
                    most_constrained_i2 = i2;
                }
            }
        }

        if(most_constrained_count == 0) {
            return false;
        }
        if(most_constrained_count == INT_MAX) {
            return true;
        }

        ValidMoves& vm = validMoves[most_constrained_i1][most_constrained_i2];
        for(int move=0; move<9; move++) {
            if(!vm.isValid(move)) {
                continue;
            }

            makeMove(board, validMoves, most_constrained_i1, most_constrained_i2, move);
            if(_solveSudoku(board, validMoves)) {
                return true;
            } else {
                unMakeMove(board, validMoves, most_constrained_i1, most_constrained_i2, move);
            }
        }

        return false;
    }
};

这里写图片描述

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
是一种经典的逻辑推理和填数字的游戏,其求解过程可以通过编写代码来实现。下面是一个简单的数求解器C代码的描述。 数求解器的主要思路是通过回溯法来逐个填充数格子,然后检查填充的数字是否满足数规则。如果填写的数字使数有效,继续递归地填写下一个格子;如果填写的数字导致数无效,则回溯到上一个格子重新尝试其他的数字。 首先,需要定义一个函数来判断当前填充的数字是否符合数规则。这个函数需要检查当前数字是否和同一行、同一列以及同一个九宫格内的其他数字冲突。如果冲突,则说明当前数字无效。 然后,编写递归函数来填充数格子。递归函数需要遍历数的每一个格子,如果当前格子已经填充了数字,则跳过;如果当前格子未填充数字,则尝试从1到9逐个填充数字,并调用前面定义的函数来判断数字是否有效。如果数字有效,则递归地填充下一个格子;如果数字无效,则回溯到上一个格子重新尝试其他的数字。 最后,调用递归函数来填充数格子。可以使用一个二维数组来表示数,并将初始的数状态作为参数传入递归函数。在递归函数结束后,如果数全部填充完毕,则表明数有解,否则无解。 这样,一个简单的数求解器C代码就完成了。通过递归和回溯的方式,可以在较短的时间内找到数的解,并打印出来。当然,为了提高求解效率,可以在代码中加入一些优化算法,如剪枝等。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值