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<int, 9> m) {
int count[16] = {0}; // 用于统计数字出现的次数
for (auto n : m) {
// 检查数字是否在 1 到 9 之间且不重复
if (n < 1 || 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<vector<int>>& grid) {
if (grid.size() < 3 || grid[0].size() < 3) {
return 0; // 如果 grid 的大小小于 3x3，直接返回 0
}
int m = grid.size(), n = grid[0].size();
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;
}
array<int, 9> 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<vector<int>>& rooms) {
int n = rooms.size(); // 房间的数量
unordered_set<int> visited; // 记录已访问的房间
queue<int> 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<int> visited;
int num;
void dfs(vector<vector<int>>& rooms, int x) {
visited[x] = true;
num++;
for (const auto& it : rooms[x]) {
if (!visited[it]) {
dfs(rooms, it);
}
}
}
public:
bool canVisitAllRooms(vector<vector<int>>& 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<int> splitIntoFibonacci(string num) {
vector<int> list; // 用于存储斐波那契序列
backtrack(list, num, num.length(), 0, 0, 0); // 调用回调函数
return list; // 返回结果
}
bool backtrack(vector<int>& 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 < length; ++i) {
if (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) {
continue; // 如果当前数字小于 sum, 继续增加数字
} else 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<vector<int>> H; // 匹配矩阵, H[i][j] 表示 words[i] 和 words[j] 的匹配数目
// 选择下一个猜测的单词
int solve(vector<int>& possible, vector<int>& path) {
if (possible.size() <= 2) {
return possible[0]; // 如果候选单词数量 <= 2，直接返回第一个
}
vector<int> ansgrp = possible;
int ansguess = -1;
// 遍历所有可能的猜测单词
for (int guess = 0; guess < H.size(); ++guess) {
if (find(path.begin(), path.end(), guess) ==
path.end()) { // 如果 guess 未被猜测过
vector<vector<int>> groups(7); // 根据匹配数目分组
for (int j : possible) {
if (j != guess) {
groups[H[guess][j]].push_back(j);
}
}
// 找到最大的组
vector<int> maxgroup = groups[0];
for (int i = 0; i < 7; ++i) {
if (groups[i].size() > maxgroup.size()) {
maxgroup = groups[i];
}
}
// 选择能够最小化最大组的猜测单词
if (maxgroup.size() < ansgrp.size()) {
ansgrp = maxgroup;
ansguess = guess;
}
}
}
return ansguess;
}
public:
void findSecretWord(vector<string>& words, Master& master) {
int N = words.size();
H = vector<vector<int>>(N, vector<int>(N, 0)); // 初始化匹配矩阵
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][k] == words[j][k]) {
match++;
}
}
H[i][j] = H[j][i] = match; // 计算匹配数目
}
}
vector<int> possible; // 候选单词列表
vector<int> path; // 已猜测的单词列表
for (int i = 0; i < N; ++i) {
possible.push_back(i);
}
while (!possible.empty()) {
int guess = solve(possible, path); // 选择下一个猜测单词
int matches = master.guess(words[guess]); // 调用 Master.guess
if (matches == words[0].length()) {
return; // 如果猜中，直接返回
}
vector<int> 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)
