第 86 场周赛：矩阵中的幻方、钥匙和房间、将数组拆分成斐波那契序列、猜猜这个单词 - 指南
2025-10-21 09:20 tlnshuju 阅读(6) 评论(0) 收藏 举报Q1、[中等] 矩阵中的幻方
1、题目描述
3 x 3 的幻方是一个填充有 从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。
给定一个由整数组成的row x col 的 grid，其中有多少个 3 × 3 的 “幻方” 子矩阵？
注意：虽然幻方只能包含 1 到 9 的数字，但 grid 可以包含最多15的数字。
示例 1：
输入: grid = [[4,3,8,4],[9,5,1,9],[2,7,6,2] 输出: 1 解释: 下面的子矩阵是一个 3 x 3 的幻方： 而这一个不是： 总的来说，在本示例所给定的矩阵中只有一个 3 x 3 的幻方子矩阵。示例 2:
输入: grid = [[8]] 输出: 0提示:
row == grid.lengthcol == grid[i].length1 <= row, col <= 100 <= grid[i][j] <= 15
2、解题思路
问题分析：
- 需要遍历
grid中所有可能的3 × 3子矩阵。 - 对于每个子矩阵，检查它是否满足幻方的条件。
- 需要遍历
幻方的条件：
- 包含
1到9的不同数字。 - 每行、每列以及两条对角线的和都等于
15。
- 包含
优化：
- 幻方的中心必须是
5，因此可以提前过滤掉中心不是5的子矩阵。
- 幻方的中心必须是
算法设计：
- 遍历
grid中所有可能的3 × 3子矩阵。 - 对于每个子矩阵，检查是否满足幻方的条件。
- 统计满足条件的子矩阵数量。
- 遍历
3、代码实现
C++
class Solution {
public:
// 检查一个 3x3 矩阵是否是幻方
bool ismagic(array m) {
int count[16] = {0}; // 用于统计数字出现的次数
for (auto n : m) {
// 检查数字是否在 1 到 9 之间且不重复
if (n 9 || ++count[n] > 1) {
return false;
}
}
// 检查每行、每列以及两条对角线的和是否等于 15
return m[0] + m[1] + m[2] == 15 && m[3] + m[4] + m[5] == 15 &&
m[6] + m[7] + m[8] == 15 && m[0] + m[3] + m[6] == 15 &&
m[1] + m[4] + m[7] == 15 && m[2] + m[5] + m[8] == 15 &&
m[0] + m[4] + m[8] == 15 && m[2] + m[4] + m[6] == 15;
}
int numMagicSquaresInside(vector>& grid) {
if (grid.size() v; // 用于存储 3x3 子矩阵的元素
int w = 0;
for (int r = i; r < i + 3; r++) { // 提取 3x3 子矩阵
for (int c = j; c < j + 3; c++) {
v[w++] = grid[r][c];
}
}
res += ismagic(v); // 检查是否是幻方
}
}
return res; // 返回幻方的数量
}
};Java
class Solution {
// 检查一个 3x3 矩阵是否是幻方
private
boolean ismagic(
int[] m) {
int[] count =
new
int[16]
;
// 用于统计数字出现的次数
for (
int n : m) {
if (n <
1 || n >
9 || ++count[n] >
1
) {
// 检查数字是否在 1 到 9 之间且不重复
return false
;
}
}
// 检查每行、每列以及两条对角线的和是否等于 15
return m[0] + m[1] + m[2] == 15 && m[3] + m[4] + m[5] == 15 &&
m[6] + m[7] + m[8] == 15 && m[0] + m[3] + m[6] == 15 &&
m[1] + m[4] + m[7] == 15 && m[2] + m[5] + m[8] == 15 &&
m[0] + m[4] + m[8] == 15 && m[2] + m[4] + m[6] == 15
;
}
public
int numMagicSquaresInside(
int[][] grid) {
if (grid.length <
3 || grid[0].length <
3
) {
return 0
;
// 如果 grid 的大小小于 3x3，直接返回 0
}
int m = grid.length, n = grid[0].length;
int res = 0
;
// 记录幻方的数量
for (
int i = 0
; i < m - 2
; i++
) {
// 遍历所有可能的起始行
for (
int j = 0
; j < n - 2
; j++
) {
// 遍历所有可能的起始列
if (grid[i + 1][j + 1] != 5
) {
// 如果中心不是 5，跳过
continue
;
}
int[] v =
new
int[9]
;
// 用于存储 3x3 子矩阵的元素
int w = 0
;
for (
int r = i; r < i + 3
; r++
) {
// 提取 3x3 子矩阵
for (
int c = j; c < j + 3
; c++
) {
v[w++] = grid[r][c]
;
}
}
res += ismagic(v) ? 1 : 0
;
// 检查是否是幻方
}
}
return res;
// 返回幻方的数量
}
}Python
class Solution:
def ismagic(self, m):
count = [0] * 16 # 用于统计数字出现的次数
for n in m:
if n <
1
or n >
9
or count[n] >
0: # 检查数字是否在 1 到 9 之间且不重复
return False
count[n] += 1
# 检查每行、每列以及两条对角线的和是否等于 15
return (
m[0] + m[1] + m[2] == 15
and m[3] + m[4] + m[5] == 15
and m[6] + m[7] + m[8] == 15
and m[0] + m[3] + m[6] == 15
and m[1] + m[4] + m[7] == 15
and m[2] + m[5] + m[8] == 15
and m[0] + m[4] + m[8] == 15
and m[2] + m[4] + m[6] == 15
)
def numMagicSquaresInside(self, grid):
if len(grid) <
3
or len(grid[0]
) <
3:
return 0 # 如果 grid 的大小小于 3x3，直接返回 0
m, n = len(grid)
, len(grid[0]
)
res = 0 # 记录幻方的数量
for i in range(m - 2
): # 遍历所有可能的起始行
for j in range(n - 2
): # 遍历所有可能的起始列
if grid[i + 1][j + 1] != 5: # 如果中心不是 5，跳过
continue
v = [
grid[r][c]
for r in range(i, i + 3
)
for c in range(j, j + 3
)
] # 提取 3x3 子矩阵
res += 1
if self.ismagic(v)
else 0 # 检查是否是幻方
return res # 返回幻方的数量
4、复杂度分析
时间复杂度：
- 遍历所有可能的
3 × 3子矩阵：O((m−2)×(n−2))。 - 检查每个子矩阵是否是幻方：O(1)。
- 总时间复杂度：O((m−2)×(n−2))。
- 遍历所有可能的
空间复杂度：
- 使用常数级别的额外空间，空间复杂度为 O(1)。
Q2、[中等] 钥匙和房间
1、题目描述
有 n 个房间，房间按从 0 到 n - 1 编号。最初，除 0 号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。
当你进入一个房间，你可能会在里面找到一套 不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。
给你一个数组 rooms 其中 rooms[i] 是你进入 i 号房间可以获得的钥匙集合。如果能进入 所有 房间返回 true，否则返回 false。
示例 1：
输入：rooms = [[1],[2],[3],[]] 输出：true 解释： 我们从 0 号房间开始，拿到钥匙 1。 之后我们去 1 号房间，拿到钥匙 2。 然后我们去 2 号房间，拿到钥匙 3。 最后我们去了 3 号房间。 由于我们能够进入每个房间，我们返回 true。示例 2：
输入：rooms = [[1,3],[3,0,1],[2],[0]] 输出：false 解释：我们不能进入 2 号房间。提示：
n == rooms.length2 <= n <= 10000 <= rooms[i].length <= 10001 <= sum(rooms[i].length) <= 30000 <= rooms[i][j] < n- 所有
rooms[i]的值 互不相同
2、解题思路
问题分析：
- 房间和钥匙的关系可以看作是一个图，其中房间是节点，钥匙是边。
- 从
0号房间开始，通过钥匙逐步解锁其他房间。 - 需要判断是否可以从
0号房间访问到所有其他房间。
算法设计：
- 使用广度优先搜索（BFS）或深度优先搜索（DFS）遍历图。
- 从
0号房间开始，将所有可以访问的房间加入集合。 - 最终检查集合的大小是否等于
n。
优化：
- 使用 BFS 或 DFS 确保所有可达房间都被访问。
3、代码实现
C++
class Solution {
public:
bool canVisitAllRooms(vector>& rooms) {
int n = rooms.size(); // 房间的数量
unordered_set visited; // 记录已访问的房间
queue q; // BFS 队列
q.push(0); // 从 0 号房间开始
visited.insert(0); // 标记 0 号房间为已访问
while (!q.empty()) { // BFS 过程
int index = q.front(); // 取出当前房间
q.pop();
for (const auto& key : rooms[index]) { // 遍历当前房间的钥匙
if (!visited.count(key)) { // 如果钥匙对应的房间未被访问
q.push(key); // 加入队列
visited.insert(key); // 标记为已访问
}
}
}
return visited.size() == n; // 判断是否访问了所有房间
}
};class Solution {
private:
vector visited;
int num;
void dfs(vector>& rooms, int x) {
visited[x] = true;
num++;
for (const auto& it : rooms[x]) {
if (!visited[it]) {
dfs(rooms, it);
}
}
}
public:
bool canVisitAllRooms(vector>& rooms) {
int n = rooms.size();
num = 0;
visited.resize(n);
dfs(rooms, 0);
return num == n;
}
};Java
class Solution {
public
boolean canVisitAllRooms(List<
List<
Integer>
> rooms) {
int n = rooms.size(
)
;
// 房间的数量
Set<
Integer> visited =
new HashSet<
>(
)
;
// 记录已访问的房间
Queue<
Integer> q =
new LinkedList<
>(
)
;
// BFS 队列
q.offer(0
)
;
// 从 0 号房间开始
visited.add(0
)
;
// 标记 0 号房间为已访问
while (!q.isEmpty(
)
) {
// BFS 过程
int index = q.poll(
)
;
// 取出当前房间
for (
int key : rooms.get(index)
) {
// 遍历当前房间的钥匙
if (!visited.contains(key)
) {
// 如果钥匙对应的房间未被访问
q.offer(key)
;
// 加入队列
visited.add(key)
;
// 标记为已访问
}
}
}
return visited.size(
) == n;
// 判断是否访问了所有房间
}
}Python
class Solution:
def canVisitAllRooms(self, rooms: List[List[int]]
) ->
bool:
n = len(rooms) # 房间的数量
visited = set(
) # 记录已访问的房间
q = deque(
) # BFS 队列
q.append(0
) # 从 0 号房间开始
visited.add(0
) # 标记 0 号房间为已访问
while q: # BFS 过程
index = q.popleft(
) # 取出当前房间
for key in rooms[index]: # 遍历当前房间的钥匙
if key not
in visited: # 如果钥匙对应的房间未被访问
q.append(key) # 加入队列
visited.add(key) # 标记为已访问
return len(visited) == n # 判断是否访问了所有房间
4、复杂度分析
- 时间复杂度：
- 每个房间和钥匙最多被访问一次，时间复杂度为 O*(*n+k)，其中
n是房间的数量，k是钥匙的总数。
- 每个房间和钥匙最多被访问一次，时间复杂度为 O*(*n+k)，其中
- 空间复杂度：
- 使用
visited集合和队列q，空间复杂度为 O(n)。
- 使用
Q3、[中等] 将数组拆分成斐波那契序列
1、题目描述
给定一个数字字符串 num，比如 "123456579"，我们可以将它分成「斐波那契式」的序列 [123, 456, 579]。
形式上，斐波那契式 序列是一个非负整数列表 f，且满足：
0 <= f[i] < 231，（也就是说，每个整数都符合 32 位 有符号整数类型）f.length >= 3- 对于所有的
0 <= i < f.length - 2，都有f[i] + f[i + 1] = f[i + 2]
另外，请注意，将字符串拆分成小块时，每个块的数字一定不要以零开头，除非这个块是数字 0 本身。
返回从 num 拆分出来的任意一组斐波那契式的序列块，如果不能拆分则返回 []。
示例 1：
输入：num = "1101111" 输出：[11,0,11,11] 解释：输出 [110,1,111] 也可以。示例 2：
输入: num = "112358130" 输出: [] 解释: 无法拆分。示例 3：
输入："0123" 输出：[] 解释：每个块的数字不能以零开头，因此 "01"，"2"，"3" 不是有效答案。提示：
1 <= num.length <= 200num中只含有数字
2、解题思路
问题分析：
- 需要将字符串
num拆分成一个斐波那契式序列。 - 序列中的每个整数必须满足
0 <= f[i] < 2^31。 - 序列的长度至少为
3，且满足斐波那契性质。 - 拆分时，不能有前导零（除非是
0本身）。
- 需要将字符串
算法设计：
- 使用回溯法枚举所有可能的拆分方式。
- 对于每个可能的拆分，检查是否满足斐波那契性质。
- 如果找到满足条件的序列，则返回结果。
优化：
在回溯过程中，如果当前数字超过
2^31 - 1，则直接剪枝。如果当前数字不满足斐波那契性质，则剪枝。
3、代码实现
C++
class Solution {
public:
vector splitIntoFibonacci(string num) {
vector list; // 用于存储斐波那契序列
backtrack(list, num, num.length(), 0, 0, 0); // 调用回调函数
return list; // 返回结果
}
bool backtrack(vector& list, string num, int length, int index, long long sum, int prev) {
if (index == length) {
return list.size() >= 3; // 如果遍历完字符串序列且序列长度 >= 3, 返回 true
}
long long curr = 0; // 当前数字
for (int i = index; i index && num[index] == '0') {
break; // 如果有前导零, 直接剪枝
}
curr = curr * 10 + (num[i] - '0'); // 计算当前数字
if (curr > INT_MAX) {
break; // 如果当前数字超过 2^31 - 1, 剪枝
}
if (list.size() >= 2) {
if (curr sum) {
break; // 如果当前数字大于 sum，剪枝
}
}
list.push_back(curr); // 将当前数字加入序列
if (backtrack(list, num, length, i + 1, prev + curr, curr)) {
return true;
}
list.pop_back(); // 回溯, 移除当前数字
}
return false; // 如果没有找到满足条件的序列, 返回 false
}
};Java
class Solution {
public List<
Integer> splitIntoFibonacci(String num) {
List<
Integer> list =
new ArrayList<
>(
)
;
// 用于存储斐波那契序列
backtrack(list, num, num.length(
)
, 0
, 0
, 0
)
;
// 调用回溯函数
return list;
// 返回结果
}
private
boolean backtrack(List<
Integer> list, String num,
int length,
int index,
long sum,
long prev) {
if (index == length) {
return list.size(
) >= 3
;
// 如果遍历完字符串且序列长度 >= 3，返回 true
}
long curr = 0
;
// 当前数字
for (
int i = index; i < length; i++
) {
if (i > index && num.charAt(index) == '0'
) {
break
;
// 如果有前导零，直接剪枝
}
curr = curr * 10 + (num.charAt(i) - '0'
)
;
// 计算当前数字
if (curr >
Integer.MAX_VALUE
) {
break
;
// 如果当前数字超过 2^31 - 1，剪枝
}
if (list.size(
) >= 2
) {
if (curr < sum) {
continue
;
// 如果当前数字小于 sum，继续增加数字
}
else
if (curr > sum) {
break
;
// 如果当前数字大于 sum，剪枝
}
}
list.add((
int
) curr)
;
// 将当前数字加入序列
if (backtrack(list, num, length, i + 1
, prev + curr, curr)
) {
return true
;
// 如果找到满足条件的序列，返回 true
}
list.remove(list.size(
) - 1
)
;
// 回溯，移除当前数字
}
return false
;
// 如果没有找到满足条件的序列，返回 false
}
}Python
class Solution:
def splitIntoFibonacci(self, num: str
) -> List[int]:
def backtrack(index, sum_val, prev, path):
if index == len(num):
return len(path) >= 3 # 如果遍历完字符串且序列长度 >= 3，返回 True
curr = 0 # 当前数字
for i in range(index, len(num)
):
if i > index and num[index] == "0":
break # 如果有前导零，直接剪枝
curr = curr * 10 + int(num[i]
) # 计算当前数字
if curr >
2**31 - 1:
break # 如果当前数字超过 2^31 - 1，剪枝
if len(path) >= 2:
if curr < sum_val:
continue # 如果当前数字小于 sum，继续增加数字
elif curr > sum_val:
break # 如果当前数字大于 sum，剪枝
path.append(curr) # 将当前数字加入序列
if backtrack(i + 1
, prev + curr, curr, path):
return True # 如果找到满足条件的序列，返回 True
path.pop(
) # 回溯，移除当前数字
return False # 如果没有找到满足条件的序列，返回 False
result = []
backtrack(0
, 0
, 0
, result)
return result
4、复杂度分析
时间复杂度：
- 最坏情况下，回溯的时间复杂度为 O(2n)，其中
n是字符串的长度。 - 由于剪枝的存在，实际运行时间会大大减少。
- 最坏情况下，回溯的时间复杂度为 O(2n)，其中
空间复杂度：
- 使用递归栈和结果列表，空间复杂度为 O(n)。
Q4、[困难] 猜猜这个单词
1、题目描述
给你一个由 不同 字符串组成的单词列表 words ，其中 words[i] 长度均为 6 。words 中的一个单词将被选作秘密单词 secret 。
另给你一个辅助对象 Master ，你可以调用 Master.guess(word) 来猜单词，其中参数 word 长度为 6 且必须是 words 中的字符串。
Master.guess(word) 将会返回如下结果：
- 如果
word不是words中的字符串，返回-1，或者 - 一个整数，表示你所猜测的单词
word与 秘密单词secret的准确匹配（值和位置同时匹配）的数目。
每组测试用例都会包含一个参数 allowedGuesses ，其中 allowedGuesses 是你可以调用 Master.guess(word) 的最大次数。
对于每组测试用例，在不超过允许猜测的次数的前提下，你应该调用 Master.guess 来猜出秘密单词。最终，你将会得到以下结果：
- 如果你调用
Master.guess的次数大于allowedGuesses所限定的次数或者你没有用Master.guess猜到秘密单词，则得到"Either you took too many guesses, or you did not find the secret word."。 - 如果你调用
Master.guess猜到秘密单词，且调用Master.guess的次数小于或等于allowedGuesses，则得到"You guessed the secret word correctly."。
生成的测试用例保证你可以利用某种合理的策略（而不是暴力）猜到秘密单词。
示例 1：
输入：secret = "acckzz", words = ["acckzz","ccbazz","eiowzz","abcczz"], allowedGuesses = 10 输出：You guessed the secret word correctly. 解释： master.guess("aaaaaa") 返回 -1 ，因为 "aaaaaa" 不在 words 中。 master.guess("acckzz") 返回 6 ，因为 "acckzz" 是秘密单词 secret ，共有 6 个字母匹配。 master.guess("ccbazz") 返回 3 ，因为 "ccbazz" 共有 3 个字母匹配。 master.guess("eiowzz") 返回 2 ，因为 "eiowzz" 共有 2 个字母匹配。 master.guess("abcczz") 返回 4 ，因为 "abcczz" 共有 4 个字母匹配。 一共调用 5 次 master.guess ，其中一个为秘密单词，所以通过测试用例。示例 2：
输入：secret = "hamada", words = ["hamada","khaled"], allowedGuesses = 10 输出：You guessed the secret word correctly. 解释：共有 2 个单词，且其中一个为秘密单词，可以通过测试用例。提示：
1 <= words.length <= 100words[i].length == 6words[i]仅由小写英文字母组成words中所有字符串 互不相同secret存在于words中10 <= allowedGuesses <= 30
2、解题思路
- 问题分析：
- 需要从
words中猜出秘密单词secret。 - 每次调用
Master.guess(word)会返回word与secret的匹配数目。 - 需要在允许的猜测次数内找到
secret。
- 需要从
- 算法设计：
- 使用启发式方法，每次选择一个单词进行猜测，并根据返回的匹配数目缩小可能的候选单词范围。
- 通过计算单词之间的匹配数目，选择能够最大程度减少候选单词数量的单词进行猜测。
- 优化：
- 使用预计算的匹配矩阵
H，其中H[i][j]表示words[i]和words[j]的匹配数目。 - 在每次猜测后，根据匹配数目过滤候选单词。
- 使用预计算的匹配矩阵
3、代码实现
C++
class Solution {
private:
vector> H; // 匹配矩阵, H[i][j] 表示 words[i] 和 words[j] 的匹配数目
// 选择下一个猜测的单词
int solve(vector& possible, vector& path) {
if (possible.size() ansgrp = possible;
int ansguess = -1;
// 遍历所有可能的猜测单词
for (int guess = 0; guess > groups(7); // 根据匹配数目分组
for (int j : possible) {
if (j != guess) {
groups[H[guess][j]].push_back(j);
}
}
// 找到最大的组
vector maxgroup = groups[0];
for (int i = 0; i maxgroup.size()) {
maxgroup = groups[i];
}
}
// 选择能够最小化最大组的猜测单词
if (maxgroup.size() & words, Master& master) {
int N = words.size();
H = vector>(N, vector(N, 0)); // 初始化匹配矩阵
for (int i = 0; i possible; // 候选单词列表
vector path; // 已猜测的单词列表
for (int i = 0; i possible2; // 新的候选单词列表
for (int j : possible) {
if (H[guess][j] == matches) {
possible2.push_back(j); // 根据匹配数目过滤候选单词
}
}
possible = possible2;
path.push_back(guess); // 将猜测单词加入已猜测列表
}
}
};Java
class Solution {
private
int[][] H
;
// 匹配矩阵，H[i][j] 表示 words[i] 和 words[j] 的匹配数目
// 选择下一个猜测的单词
private
int solve(List<
Integer> possible, List<
Integer> path) {
if (possible.size(
) <= 2
) {
return possible.get(0
)
;
// 如果候选单词数量 <= 2，直接返回第一个
}
List<
Integer> ansgrp = possible;
int ansguess = -1
;
// 遍历所有可能的猜测单词
for (
int guess = 0
; guess <
H.length; guess++
) {
if (!path.contains(guess)
) {
// 如果 guess 未被猜测过
List<
List<
Integer>
> groups =
new ArrayList<
>(7
)
;
for (
int i = 0
; i <
7
; i++
) {
groups.add(
new ArrayList<
>(
)
)
;
}
for (
int j : possible) {
if (j != guess) {
groups.get(H[guess][j]
).add(j)
;
// 根据匹配数目分组
}
}
// 找到最大的组
List<
Integer> maxgroup = groups.get(0
)
;
for (
int i = 0
; i <
7
; i++
) {
if (groups.get(i).size(
) > maxgroup.size(
)
) {
maxgroup = groups.get(i)
;
}
}
// 选择能够最小化最大组的猜测单词
if (maxgroup.size(
) < ansgrp.size(
)
) {
ansgrp = maxgroup;
ansguess = guess;
}
}
}
return ansguess;
}
public
void findSecretWord(String[] words, Master master) {
int N = words.length;
H =
new
int[N][N]
;
// 初始化匹配矩阵
for (
int i = 0
; i <
N
; i++
) {
for (
int j = i; j <
N
; j++
) {
int match = 0
;
for (
int k = 0
; k <
6
; k++
) {
if (words[i].charAt(k) == words[j].charAt(k)
) {
match++
;
}
}
H[i][j] = H[j][i] = match;
// 计算匹配数目
}
}
List<
Integer> possible =
new ArrayList<
>(
)
;
// 候选单词列表
List<
Integer> path =
new ArrayList<
>(
)
;
// 已猜测的单词列表
for (
int i = 0
; i <
N
; i++
) {
possible.add(i)
;
}
while (!possible.isEmpty(
)
) {
int guess = solve(possible, path)
;
// 选择下一个猜测单词
int matches = master.guess(words[guess]
)
;
// 调用 Master.guess
if (matches == words[0].length(
)
) {
return
;
// 如果猜中，直接返回
}
List<
Integer> possible2 =
new ArrayList<
>(
)
;
// 新的候选单词列表
for (
int j : possible) {
if (H[guess][j] == matches) {
possible2.add(j)
;
// 根据匹配数目过滤候选单词
}
}
possible = possible2;
path.add(guess)
;
// 将猜测单词加入已猜测列表
}
}
}Python
class Solution:
def __init__(self):
self.H = [] # 匹配矩阵，H[i][j] 表示 words[i] 和 words[j] 的匹配数目
# 选择下一个猜测的单词
def solve(self, possible: List[int]
, path: List[int]
) ->
int:
if len(possible) <= 2:
return possible[0] # 如果候选单词数量 <= 2，直接返回第一个
ansgrp = possible
ansguess = -1
# 遍历所有可能的猜测单词
for guess in range(len(self.H)
):
if guess not
in path: # 如果 guess 未被猜测过
groups = [[]
for _ in range(7
)] # 根据匹配数目分组
for j in possible:
if j != guess:
groups[self.H[guess][j]].append(j)
# 找到最大的组
maxgroup = groups[0]
for i in range(7
):
if len(groups[i]
) >
len(maxgroup):
maxgroup = groups[i]
# 选择能够最小化最大组的猜测单词
if len(maxgroup) <
len(ansgrp):
ansgrp = maxgroup
ansguess = guess
return ansguess
def findSecretWord(self, words: List[str]
, master: "Master"
) ->
None:
N = len(words)
self.H = [[0] * N for _ in range(N)] # 初始化匹配矩阵
for i in range(N):
for j in range(i, N):
match = 0
for k in range(6
):
if words[i][k] == words[j][k]:
match += 1
self.H[i][j] = self.H[j][i] =
match # 计算匹配数目
possible = list(range(N)
) # 候选单词列表
path = [] # 已猜测的单词列表
while possible:
guess = self.solve(possible, path) # 选择下一个猜测单词
matches = master.guess(words[guess]
) # 调用 Master.guess
if matches == len(words[0]
):
return # 如果猜中，直接返回
possible = [
j for j in possible if self.H[guess][j] == matches
] # 根据匹配数目过滤候选单词
path.append(guess) # 将猜测单词加入已猜测列表
4、复杂度分析
- 时间复杂度：
- 时间复杂度：O(N2logN)，其中 N 是单词的总数
- 空间复杂度：
- 空间复杂度：O(N2)
浙公网安备 33010602011771号