LeetCode 753. Cracking the Safe

最新推荐文章于 2025-06-12 07:15:00 发布

taoqick

最新推荐文章于 2025-06-12 07:15:00 发布

阅读量201

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode python3

本文链接：https://blog.youkuaiyun.com/taoqick/article/details/104719305

leetcode 同时被 2 个专栏收录

231 篇文章

订阅专栏

python3

120 篇文章

订阅专栏

本文介绍了一种基于欧拉图的密码箱解锁算法，通过构造一个包含所有可能密码组合的序列，确保在输入过程中能够匹配并打开任何由n位k进制数字组成的密码保护的箱子。算法采用深度优先搜索(DFS)的后序遍历实现，同时提供了递归和非递归两种实现方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

There is a box protected by a password. The password is a sequence of n digits where each digit can be one of the first k digits 0, 1, ..., k-1.

While entering a password, the last n digits entered will automatically be matched against the correct password.

For example, assuming the correct password is "345", if you type "012345", the box will open because the correct password matches the suffix of the entered password.

Return any password of minimum length that is guaranteed to open the box at some point of entering it.

Example 1:

Input: n = 1, k = 2
Output: "01"
Note: "10" will be accepted too.

Example 2:

Input: n = 2, k = 2
Output: "00110"
Note: "01100", "10011", "11001" will be accepted too.

Note:

n will be in the range [1, 4].
k will be in the range [1, 10].
k^n will be at most 4096.

----------------------------------------------------------------------------------------------------

关键点在于理解这是一个欧拉图，把n-1位数看做是k^(n-1)个状态，状态之间的跳转恰好是边，边对应一个密码。题目是要求一个序列能覆盖所有的边，恰好是欧拉图的一笔画问题，解法就是DFS的后序遍历，这思路和 https://blog.youkuaiyun.com/taoqick/article/details/104147688 （虽然不是欧拉图）很像

class Solution:
    def dfs(self, cur, seen, res, k):
        for strk in [str(i) for i in range(k)]:
            edge = cur + strk
            if (edge not in seen):
                seen.add(edge)
                self.dfs(edge[1:], seen, res, k)
                res.append(strk) #bug1: 先self.dfs(edge[1:], seen, res, k)，后res.append(strk)

    def crackSafe(self, n: int, k: int):
        res = []
        init = "0" * (n - 1)
        self.dfs(init, set(), res, k)
        return ''.join(res) + init

s = Solution()
print(s.crackSafe(n = 2, k = 2))

再补一个非递归的栈顶元素取儿子法，注意这里难点就是区分什么是边，什么是点，以及初始值：

class Solution:
    def find_not_visited_edge(self, node, edge_seen, k):
        for i in range(k):
            edge = node + str(i)
            if (edge not in edge_seen):
                edge_seen.add(edge)
                return edge
        return None

    def crackSafe(self, n: int, k: int):
        edge_seen, sta, res = {"0" * n}, ["0" * n], []
        while (sta):
            edge = self.find_not_visited_edge(sta[-1][1:], edge_seen, k)
            while (edge != None):
                sta.append(edge)
                edge = self.find_not_visited_edge(sta[-1][1:], edge_seen, k)
            if (sta):
                res.append(sta.pop()[-1])
        return ''.join(res) + "0" * (n-1)