比特币和它的神秘缔造者中本聪的谜题能否被揭晓？剑指 offer - 129：字母迷宫

比特币（Bitcoin）是一种基于区块链技术的数字货币，自2009年由神秘人物或团体中本聪（Satoshi Nakamoto）推出以来，迅速成为全球最知名和广泛使用的加密货币。比特币的概念最早由中本聪在2008年提出，并在次年正式推出。作为一种去中心化的数字货币，比特币没有中央银行或政府机构控制和发行，而是通过一种称为区块链的分布式账本技术来实现交易记录和验证。

然而，比特币的神秘作者中本聪的身份一直是加密货币领域最引人入胜的谜团之一。尽管中本聪这个名字在比特币世界中如雷贯耳，但关于其背后的真人或团队却始终笼罩在一层厚重的面纱之下。

中本聪的真实身份之所以如此神秘，可能与他/他们希望保护隐私和个人安全、强调去中心化、防止权力集中以及避免法律和监管压力等因素有关。此外，在比特币早期发展阶段，各国政府对比特币的态度并不明朗，若中本聪的真实身份曝光，可能面临严格的法规审查或法律风险。

美国的 HBO 新纪录片则声称他们拿到了中本聪的真实身份，纪录片将于美国东部时间周二晚上9点播出。

CSDN - 本博客python入门笔记快捷下载

免费下载 - MySQL和Oracle的详细区别

CSDN - 本博客C++入门笔记快捷下载

今天的剑指 offer 刷题活动：

剑指 offer 题目：

题号：LCR 129

字母迷宫游戏初始界面记作 m x n 二维字符串数组 grid，请判断玩家是否能在 grid 中找到目标单词 target。
注意：寻找单词时 必须 按照字母顺序，通过水平或垂直方向相邻的单元格内的字母构成，同时，同一个单元格内的字母 不允许被重复使用 。

剑指 offer 解题思路：

思路一：回溯（对矩阵中的每个元素都进行一次深度优先搜索）

1、初始检查：

首先检查输入的网格是否为空，即 grid.size() == 0 或 grid[0].size() == 0。如果是空网格，则直接返回 false，因为无法在空网格中找到任何路径。

2、初始化变量：

获取网格的行数 row 和列数 line。

获取目标字符串的长度 ssize。

创建一个与网格大小相同的布尔类型二维数组 visit，用于记录网格中的每个位置是否已经被访问过，以避免重复访问。

3、定义回溯函数 backTrace：

如果当前位置越界、已被访问过、或者网格中的字符与目标字符串中的字符不匹配，则返回 false。

如果已经遍历到目标字符串的最后一个字符（即 k == ssize - 1），说明找到了匹配的路径，返回 true。

使用 lambda 表达式定义一个递归的回溯函数 backTrace，该函数接受三个参数：当前位置的行索引 i，列索引 j，以及当前在目标字符串中的索引 k。

3 - 1 回溯函数 结束条件：

将当前位置标记为已访问。

递归地尝试四个方向（右、下、左、上）的移动，只要有一个方向能成功找到匹配路径，则返回 true。

回溯时取消当前位置的访问标记，以便其他路径可以尝试访问该位置。

4、遍历网格：

使用两层循环遍历网格中的每个位置。

对每个位置，调用回溯函数 backTrace，从目标字符串的第一个字符开始匹配。

如果在某个位置找到了匹配路径，直接返回 true。

5、返回结果：

如果遍历完整个网格后仍未找到匹配路径，则返回 false。

时间复杂度：O(3^n * row * line)

空间复杂度：O(row * line)

C++

// C++
class Solution {
public:
    bool wordPuzzle(vector<vector<char>>& grid, string target) {
        if(grid.size() == 0 || grid[0].size() == 0) {
            return false;
        }
        int row = grid.size();
        int line = grid[0].size();
        int ssize = target.size();
        vector<vector<bool>> visit(row, vector<bool>(line, false));
        function<bool(int, int, int)> backTrace = [&](int i, int j, int k) -> bool {
            // 结束条件
            if(i < 0 || i >= row || j < 0 || j >= line || visit[i][j] || grid[i][j] != target[k]) {
                return false;
            }
            // 找到了
            if(k == ssize - 1) {
                return true;
            }

            visit[i][j] = true;
            bool res = backTrace(i, j + 1, k + 1) || backTrace(i + 1, j, k + 1) || backTrace(i, j - 1, k + 1) || backTrace(i - 1, j, k + 1);
            visit[i][j] = false;
            return res;
        };

        for(int i = 0; i < row; i++) {
            for(int j = 0; j < line; j++) {
                if(backTrace(i, j, 0)) {
                    return true;
                }
            }
        }

        return false;
    }
};

go

// go
func wordPuzzle(grid [][]byte, target string) bool {
    n := len(grid)
    m := len(grid[0])
    l := len(target)
    visited := make([][]bool, n)
    for i := range visited {
        visited[i] = make([]bool, m)
    }

    var backTrace func(int, int, int) bool
    backTrace = func(i, j, k int) bool {
        if i < 0 || i >= n || j < 0 || j >= m || visited[i][j] || grid[i][j] != target[k] {
            return false
        }

        if k == l-1 {
            return true
        }

        visited[i][j] = true
        res := backTrace(i, j+1, k+1) || backTrace(i+1, j, k+1) || backTrace(i, j-1, k+1) || backTrace(i-1, j, k+1)
        visited[i][j] = false

        return res
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            if backTrace(i, j, 0) {
                return true
            }
        }
    }

    return false
}