【leetcode-37 解数独 | Rust 】3 种回溯、4种数据结构共 12 种方式对比

最新推荐文章于 2023-03-11 13:38:44 发布
最新推荐文章于 2023-03-11 13:38:44 发布
阅读量233 收藏 1
点赞数
分类专栏： Rust 文章标签： leetcode rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37952030/article/details/118942184
版权
该博客文章详细介绍了利用 Rust 编程语言实现 Sudoku 解决器的不同方法，对比了基于位操作（如 RcbBit、RcbBits）和数组（如 RcbArr、RcbArrs）数据结构的性能。通过 Backtrace 回溯算法，作者展示了如何记录、不记录空位置以及验证解决方案对性能的影响。文章提供了各种实现的运行时间，帮助读者理解不同数据结构的选择对算法效率的贡献。
摘要由CSDN通过智能技术生成

完整代码：_0037_sudoku_solver.rs

// 测试结果仅供参考：
// solve_sudoku_arrs_record:       122,181 ns/iter (+/- 7,597)
// solve_sudoku_arr_record:        126,718 ns/iter (+/- 4,754)
// solve_sudoku_arrs_simple:       127,047 ns/iter (+/- 5,597)
// solve_sudoku_bit_simple:        128,923 ns/iter (+/- 5,457)
// solve_sudoku_arr_simple:        129,896 ns/iter (+/- 6,582)
// solve_sudoku_bits_simple:       129,547 ns/iter (+/- 83,216)
// solve_sudoku_bit_valid_record:  133,999 ns/iter (+/- 8,108)
// solve_sudoku_bits_valid_record: 135,327 ns/iter (+/- 73,912)
// solve_sudoku_bit_record:        139,431 ns/iter (+/- 5,925)
// solve_sudoku_bits_record:       139,230 ns/iter (+/- 48,954)
// solve_sudoku_arrs_valid_record: 141,431 ns/iter (+/- 20,204)
// solve_sudoku_arr_valid_record:  145,287 ns/iter (+/- 49,714)

利用 Sudoku trait 和 Backtrace 可继续拓充算法或者数据结构

/// https://leetcode-cn.com/problems/sudoku-solver
pub struct Solution;

/// 对比不同数据结构的性能
impl Solution {
    pub fn solve_sudoku_bit_simple(board: &mut Vec<Vec<char>>) {
        let (board, mut rcb) = Solution::simple(board, RcbBit::new());
        Backtrace::simple(0, 0, board, &mut rcb);
    }

    pub fn solve_sudoku_bit_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbBit::new());
        Backtrace::record(0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_bit_valid_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbBit::new());
        let mut valid = false;
        Backtrace::valid_record(&mut valid, 0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_bits_simple(board: &mut Vec<Vec<char>>) {
        let (board, mut rcb) = Solution::simple(board, RcbBits::new());
        Backtrace::simple(0, 0, board, &mut rcb);
    }

    pub fn solve_sudoku_bits_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbBits::new());
        Backtrace::record(0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_bits_valid_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbBits::new());
        let mut valid = false;
        Backtrace::valid_record(&mut valid, 0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_arr_simple(board: &mut Vec<Vec<char>>) {
        let (board, mut rcb) = Solution::simple(board, RcbArr::new());
        Backtrace::simple(0, 0, board, &mut rcb);
    }

    pub fn solve_sudoku_arr_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbArr::new());
        Backtrace::record(0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_arr_valid_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbArr::new());
        let mut valid = false;
        Backtrace::valid_record(&mut valid, 0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_arrs_simple(board: &mut Vec<Vec<char>>) {
        let (board, mut rcb) = Solution::simple(board, RcbArrs::new());
        Backtrace::simple(0, 0, board, &mut rcb);
    }

    pub fn solve_sudoku_arrs_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbArrs::new());
        Backtrace::record(0, &v, board, &mut rcb);
    }

    pub fn solve_sudoku_arrs_valid_record(board: &mut Vec<Vec<char>>) {
        let (v, board, mut rcb) = Solution::record(board, RcbArrs::new());
        let mut valid = false;
        Backtrace::valid_record(&mut valid, 0, &v, board, &mut rcb);
    }
}

/// record: 记录空位置；simple: 不记录空位置
impl Solution {
    fn simple<T: Sudoku>(board: &mut [Vec<char>], mut rcb: T) -> (&mut [Vec<char>], T) {
        // 技巧：经过测试，数组遍历元素时，使用迭代器比下标访问更快（对比的代码就不补充了）
        for (i, r) in board.iter().enumerate() {
            for (j, &c) in r.iter().enumerate() {
                let k = i / 3 * 3 + j / 3;
                if c != '.' {
                    let d = c as usize - 49;
                    rcb.flip(i, j, k, d);
                }
            }
        }
        (board, rcb)
    }

    fn record<T: Sudoku>(board: &mut [Vec<char>], mut rcb: T)
                         -> (Vec<[usize; 3]>, &mut [Vec<char>], T) {
        let mut v: Vec<[usize; 3]> = Vec::with_capacity(81); // 记录空位置
        for (i, r) in board.iter().enumerate() {
            for (j, &c) in r.iter().enumerate() {
                let k = i / 3 * 3 + j / 3;
                if c != '.' {
                    let d = c as usize - 49;
                    rcb.flip(i, j, k, d);
                } else {
                    v.push([i, j, k]);
                }
            }
        }
        (v, board, rcb)
    }
}

struct Backtrace;

/// 回溯/递归：三种方式
#[rustfmt::skip]
impl Backtrace {
    fn simple(mut i: usize, mut j: usize, board: &mut [Vec<char>], rcb: &mut impl Sudoku) -> bool {
        if j == 9 { i += 1; j = 0; }
        if i == 9 { return true; }
        if board[i][j] != '.' { return Backtrace::simple(i, j + 1, board, rcb); }
        let k = i / 3 * 3 + j / 3;
        for d in 0..9 {
            if rcb.check(i, j, k, d) {
                rcb.flip(i, j, k, d);
                board[i][j] = (d as u8 + 49) as char;
                if Backtrace::simple(i, j + 1, board, rcb) { return true; }
                board[i][j] = '.';
                rcb.flip(i, j, k, d);
            }
        }
        false
    }

    fn record(pos: usize, v: &[[usize; 3]], board: &mut [Vec<char>], rcb: &mut impl Sudoku) -> bool {
        if pos == v.len() { return true; }
        let &[i, j, k] = &v[pos];
        for d in 0..9 {
            if rcb.check(i, j, k, d) {
                rcb.flip(i, j, k, d);
                board[i][j] = (d as u8 + 49) as char;
                if Backtrace::record(pos + 1, v, board, rcb) { return true; }
                board[i][j] = '.';
                rcb.flip(i, j, k, d);
            }
        }
        false
    }

    fn valid_record(valid: &mut bool, pos: usize, v: &[[usize; 3]], 
                    board: &mut [Vec<char>], rcb: &mut impl Sudoku) {
        if pos == v.len() { return *valid = true; }
        let &[i, j, k] = &v[pos];
        for d in 0..9 {
            if rcb.check(i, j, k, d) {
                rcb.flip(i, j, k, d);
                board[i][j] = (d as u8 + 49) as char;
                Backtrace::valid_record(valid, pos + 1, v, board, rcb);
                rcb.flip(i, j, k, d);
            }
            if *valid { return (); }
        }
    }
}

trait Sudoku {
    fn new() -> Self;
    /// 在这个算法中，已经提前判断了逻辑，所以每次都是反转这个结果
    fn flip(&mut self, i: usize, j: usize, k: usize, d: usize);
    fn check(&self, i: usize, j: usize, k: usize, d: usize) -> bool;
}

struct RcbBit([[u16; 9]; 3]);

impl Sudoku for RcbBit {
    fn new() -> Self { Self([[0; 9]; 3]) }

    fn flip(&mut self, i: usize, j: usize, k: usize, d: usize) {
        self.0[0][i] ^= 1 << d;
        self.0[1][j] ^= 1 << d;
        self.0[2][k] ^= 1 << d;
    }

    fn check(&self, i: usize, j: usize, k: usize, d: usize) -> bool {
        let n = 1 << d;
        ((self.0[0][i] & n) | (self.0[1][j] & n) | (self.0[2][k] & n)).eq(&0)
    }
}

#[rustfmt::skip]
struct RcbBits { // 第 d 位的 0 代表无数字，实际只需要后 0-8 位（u8 只有 0-7 共 8 位）
    row: [u16; 9], col: [u16; 9], block: [u16; 9]
}

impl Sudoku for RcbBits {
    #[rustfmt::skip]
    fn new() -> Self {
        Self { row: [0; 9], col: [0; 9], block: [0; 9] }
    }

    fn flip(&mut self, i: usize, j: usize, k: usize, d: usize) {
        // 把第 d 位数字（表示数 d+1 ）设置为相反数
        self.row[i] ^= 1 << d;
        self.col[j] ^= 1 << d;
        self.block[k] ^= 1 << d;
    }

    fn check(&self, i: usize, j: usize, k: usize, d: usize) -> bool {
        // a & (1 << d) 检查 a 的第 d 位是不是 0：如果是 0 ，则返回 0；不是 0 返回非 0
        // 这里的位运算虽然不像 bools 那样最少可以比对一次，
        // 但位运算在这一个测试例子里大概快 7000 ns ，花销可能在于数字到 bool 的转换需要 eq
        // let cmp = |n: u16| (n & (1 << d)).eq(&0);
        // cmp(self.row[i]) && cmp(self.col[j]) && cmp(self.block[k])
        let n = 1 << d;
        ((self.row[i] & n) | (self.col[j] & n) | (self.block[k] & n)).eq(&0)
    }
}

struct RcbArr([[[bool; 9]; 9]; 3]);

impl Sudoku for RcbArr {
    #[rustfmt::skip]
    fn new() -> Self {
        Self([[[false; 9]; 9];3])
    }

    fn flip(&mut self, i: usize, j: usize, k: usize, d: usize) {
        self.0[0][i][d] ^= true; // 取反
        self.0[1][j][d] ^= true;
        self.0[2][k][d] ^= true;
    }

    fn check(&self, i: usize, j: usize, k: usize, d: usize) -> bool {
        !self.0[0][i][d] && !self.0[1][j][d] && !self.0[2][k][d]
    }
}

/// 当然，也可以把 bool 换成整数，使用位运算，比如
/// https://rustgym.com/leetcode/37
#[rustfmt::skip]
struct RcbArrs { // row：第一层代表第 i 行，第二层代表 1-9 的每个数字； col、block 类似
    row: [[bool; 9]; 9], col: [[bool; 9]; 9], block: [[bool; 9]; 9],
}

impl Sudoku for RcbArrs {
    #[rustfmt::skip]
    fn new() -> Self {
        Self { row: [[false; 9]; 9], col: [[false; 9]; 9], block: [[false; 9]; 9] }
    }

    fn flip(&mut self, i: usize, j: usize, k: usize, d: usize) {
        self.row[i][d] ^= true; // 取反
        self.col[j][d] ^= true;
        self.block[k][d] ^= true;
    }

    fn check(&self, i: usize, j: usize, k: usize, d: usize) -> bool {
        !self.row[i][d] && !self.col[j][d] && !self.block[k][d]
    }
}
Mr_Vague
关注
专栏目录
rust-n-queens:在 Rust 中实现的 n-queens 的快速并行回溯算法
07-07
Rust 中的 N-Queens 在 Rust 中实现的 n-queens 的超快速并行回溯算法。 30,000 英尺概览： 我们完成所有工作的内部辅助函数只需要几个参数：三个整数，代表当前行上被先前皇后阻止的点。 这里的“秘诀”是我们可以避免绕过棋盘甚至之前皇后的位置，而是使用这些信息来推断下一行的冲突。 一旦我们知道当前行中的冲突，我们就可以简单地递归所有空位和利润。 然后我们可以使用 bit magic 来显着加速数组的过程——几乎是 50 倍的加速。 n=12 的时间：500k ns。 最高计算结果：n=17 请参阅 nqueens.rs 以获得对该算法的更详细的解释，包括对所有位魔法的彻底解释。 对于在 js 中实现的相同算法（大约慢 200 倍），请参阅我的 n-queens.js 存储库。
iOS LeetCode☞解数独
HumorousGhost
04-25 324
编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 '.' 表示。 示例： 输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".","
Leetcode 37 递归回溯。
wwxy1995的博客
06-20 192
这就是一个经典的回溯递归问题，一个格子一个格子的填写，递归到下一层 递归回溯的方法是每一格子1-9逐个填写，因为数读只有唯一解，因此这种搜索的方法一定可以找到答案。 class Solution { public: bool flagRow[9][9]; // 第一个下标个代表行号，第二个下标代表该数字是否用过 bool flagCol[9][9]; // 第一个下标代表列号， 第二个下标代表该数字是否用过 b.
【dawn·数据结构】解数独问题(C++)
Iridescent_fd的博客
12-08 844
简要说明： (1)题目来源网络（题目要求和输入样例参考LeetCode相同题目） 链接：https://leetcode-cn.com/problems/sudoku-solver/ (2)由于作者水平限制和时间限制，代码本身可能仍有一些瑕疵，仍有改进的空间。也欢迎大家一起来讨论。 ——一个大二刚接触《数据结构》课程的菜鸡留 题目简介 编写一个程序，给定部分格子及数字，通过填充空格来完成数独。对于数独有如下要求： 1、数字1-9在每一行只出现一次。 2、数字1-9在每一列只出现一次。 3、数字1-9在.
【亡羊补牢】挑战数据结构与算法 第30期 LeetCode 37. 解数独（递归与回溯）
超逸の学习技术博客
09-18 340
仰望星空的人，不应该被嘲笑 题目描述 编写一个程序，通过填充空格来解决数独问题。 一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。 一个数独。 答案被标成红色。 提示： 给定的数独序列只包含数字 1-9 和字符 '.' 。 你可以假设给定的数独只有唯一解。 给定数独永远是 9x9 形式的。 来源：力扣（LeetCode） 链接：https://le..
leetcode中国-leetcode-rust-cn:用Rust刷LeetCode，带中文注释
06-29
leetcode-rust-cn LeetCode solutions in Rust, with Chinese comment. 用 Rust 刷 LeetCode，带中文注释 VSCode 插件 ，插件用法见其 插件 插件 切换到 LeetCode 英文版，然后通过第三方帐号(如 GitHub)登录 用法：...
leetcode——-解数独(回溯法)
01-20
回溯法的思想就是：对于一个问题有多个选择方式，先选择一个方式执行下去，若在执行过程中，发现不符合规则，则回退，回到选择方式的步骤，进而选择其他方式，继续试。 重要：对于回溯法，一定会有个[规则]，这个...
leetcoderust-cauly-rust-leetcode-utils:cauly-rust-leetcode-utils
06-30
锈cauly-rust-leetcode-utils 这个项目为用 rust 语言编写 leetcode 提供了一些帮助。 如何使用 方法一： [Folk and] 克隆这个 repo。 在你的 leetcode cargo.toml 中，添加： [dependencies] cauly-rust-leetcode-...
leetcode分类-leetcode-rust:leetcode的rust版本，顺便使用rust来练手
06-30
总结来说，"leetcode-rust"项目是学习和实践Rust语言的一个宝贵资源，它挑战了Rust在处理传统数据结构时的局限，同时也展示了Rust作为系统级语言的强大之处。无论是为了提升算法能力，还是为了深入理解Rust，这个...
leetcoderust-impl-leetcode-for-rust:Rust中的LeetCode解决方案
06-30
4. **结构体与枚举的实现**：在Rust中，你可以为自定义数据类型实现方法，这在处理复杂数据结构时非常方便。LeetCode的许多题目涉及到数据结构的设计和操作，理解如何高效地实现这些结构是解题的关键。 5. **迭代器...
数据结构课设-数独游戏
01-31
请设计一个数独游戏，要求包括： 1， 基本要求：能按照不同难度级别设置随机的初始数独，允许用户在空格处填入数字完成数独游戏；在用户输入数字时，判断冲突，给出错误提示；计时，记录用户完成数独所用时间。 2， 补充要求：设计出具有唯一解的数独布局；设计出更符合实际情况的难度值；不使用回溯算法快速求解数独。 建议使用JavaScript／HTML／CSS编程，使用回溯算法。
数独解、多解（数据结构、栈、回溯法）
qq_51727767的博客
11-09 1945
首先因为个人原因前段时间在解一个数独，因为很难解不出来，再加上我王哥的启发，就想的写个程序来解决这类问题，于是就有了这篇文章。。。还有最近在学数据结构，里面很多东西用的都是比较繁琐的解决办法，比如链式存储，链栈之类的，但这样思路比较清晰。 1.程序大致思路 将数组元素全部初始化为0，然后将空位的行列入栈，然后开始给栈顶元素的空位逐步++；每次++都要判断这个数填在这个空位合不合适，合适的话入栈下一个元素，否则就出栈，这样就回溯到了上一个空...
【数据结构】有效数独
-
07-11 308
哈希表
【华为机试045】Sudoku
KittyGirl
07-10 573
题目描述：问题描述：数独（Sudoku）是一款大众喜爱的数字逻辑游戏。玩家需要根据9X9盘面上的已知数字，推算出所有剩余空格的数字，并且满足每一行、每一列、每一个粗线宫内的数字均含1-9，并且不重复。输入：包含已知数字的9X9盘面数组[空缺位以数字0表示]输出：完整的9X9盘面数组Java实现：import java.util.*; public class Main { public...
徐松亮算法教学-基于C语言的数独(九宫格)求解（含多解和解数统计）
xslxhn的专栏
11-06 3887
版权声明：本文为博主徐松亮的原创作品，未经允许不得转载，多谢支持！QQ：5387603 推荐点击此链接：欢迎进入徐松亮博客一站式导航搜索(随时更新) 目录 一，前言 二，开发环境 电脑系统 编译器 编程语言 编辑与工程环境 三，编程思路与流程 流程 设计数独数据结构 编写测试代码框架 编写核心代码---接口函数 编写核心代码---寻找下一个空单元 编写核心代码---利...
C++和Rust_打算用leetcode来试试rust
weixin_39616477的博客
11-21 213
看rust的教程，基本的地方感觉都看懂了，但是真正写出来代码无数编译错误，所以打算先用leetcode来练习一下。目前已经做了几十道题了，写了上千行代码，感觉有点入门了，从模仿C++风格慢慢地转变成有点像rust风格了。以第一题two sum为例，用hashmap，可以实现成这样：impl对于Some(&index)，如果少写了&，就会出现编译错误。当然将该行改成这样也可以：Som...
数据结构刷题（二十三）：47全排列II、51N皇后、37解数独
最新发布
xiaomingming99的博客
03-11 219
47全排列II、51N皇后、37解数独
数独求解
Mic_H的博客
04-14 1172
题目链接 分析：数独的详细规则请参照--百度百科（这里就不设传送门啦，有兴趣的同学自行前往~）。 简单来说就是每一行、每一列都要有1~9的每个数字，既然是每个都要有，意味着不能重复。然而还有一个隐藏特征，就是九宫格（3*3）里面也得刚好是1~9. 用DFS试探和回溯就可以求出来，详细注解见代码。 #include <iostream> #include <cstdio&g...
数独-dfs
Galaxy
06-05 418
【问题描述】 数独是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9X9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫内的数字均含1-9，不重复。要求使用合适的数据结构和算法，求解出所有剩余空格的数字。 【输入形式】 输入为9X9的二维数组，每个数字均为0-9之间的数字，其中0表示该位置的数字为未知。 【输出形式】 输出为9X9的二维数组，每个数字均为1-9之间的数字，满足 【样例输入】 0 0 3 5 0 0 0 0 2 0 0 8 6 0 0 0 0 0 0 7 0 0
Python实现LeetCode第170题-两数之和III数据结构设计题解
资源摘要信息:"python-leetcode面试题解之第170题两数之和III数据结构设计-题解.zip" ### 知识点详细说明： #### 标题分析： - **python**：表示该题解是使用Python语言编写。 - **leetcode**：这是一个在线编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值