介绍
豆包青训营是由字节跳动和稀土掘金社区共同发起的技术培训和人才选拔项目，主要面向在校大学生。该项目的目标是培养具有职业竞争力的优秀开发工程师，并提供全程免费的课程，不收取任何费用。
课程内容和方向
豆包青训营的课程涵盖前端、后端和AI方向。在这个飞速发展的AI时代，学员将与豆包MarsCode团队一起深入探索技术领域，学习和运用AI，提高编程效率。此外，课程还包括大数据方向，适合对大数据感兴趣的学员学习，
本文提供训练营试题解析供参考
试题1：0,1背包最大价值问题
问题描述：
一个旅行者外出旅行时需要将 n 件物品装入背包，背包的总容量为 m。每个物品都有一个重量和一个价值。你需要根据这些物品的重量和价值，决定如何选择物品放入背包，使得在不超过总容量的情况下，背包中物品的总价值最大。
给定两个整数数组 weights 和 values，其中 weights[i] 表示第 i 个物品的重量，values[i] 表示第 i 个物品的价值。你需要输出在满足背包总容量为 m 的情况下，背包中物品的最大总价值。
public class Main {
public static int solution(int n, int[] weights, int[] values, int m) {
// 定义 dp 数组
int[][] dp = new int[n + 1][m + 1];
// 遍历每个物品
for (int i = 1; i <= n; i++) {
int weight = weights[i - 1];
int value = values[i - 1];
// 遍历每个容量
for (int j = 0; j <= m; j++) {
// 如果不选当前物品
dp[i][j] = dp[i - 1][j];
// 如果选择当前物品
if (j >= weight) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - weight] + value);
}
}
}
return dp[n][m];
}
public static void main(String[] args) {
System.out.println(solution(3, new int[]{2, 1, 3}, new int[]{4, 2, 3}, 3)); // 输出: 6
System.out.println(solution(4, new int[]{1, 2, 3, 2}, new int[]{10, 20, 30, 40}, 5)); // 输出: 70
System.out.println(solution(2, new int[]{1, 4}, new int[]{5, 10}, 4)); // 输出: 10
}
}
试题2：P整数生成问题
问题描述：
小S正在玩一个数字游戏，游戏中要求生成所有小于或等于 m 的 P整数。一个整数如果可以表示为 x^i + y^j，其中 i >= 0 且 j >= 0，我们称之为强整数。请帮小S找到所有满足条件的强整数，并将结果从小到大返回，每个值最多出现一次。
def solution(x: int, y: int, m: int) -> list:
strong_integers = set()
# 计算 x 的所有幂次
i = 0
while (x**i) <= m:
# 计算 y 的所有幂次
j = 0
while (x**i + y**j) <= m:
strong_integers.add(x**i + y**j)
j += 1
if y == 1: # 防止 y=1 的死循环
break
i += 1
if x == 1: # 只需计算一次，因为 1 的幂总是 1
break
return sorted(strong_integers)
if __name__ == '__main__':
print(solution(x=2, y=3, m=10) == [2, 3, 4, 5, 7, 9, 10])
print(solution(x=3, y=5, m=15) == [2, 4, 6, 8, 10, 14])
print(solution(x=2, y=1, m=20) == [2, 3, 5, 9, 17])
print(solution(x=1, y=1, m=10) == [2]) # 示例测试
试题3：Zamn三元组的计数
问题描述：
小U定义了两个数 X 和 Y 是 “Zamn” 的，如果它们具有不同的奇偶性。也就是说，如果 X 是奇数，而 Y 是偶数，或者 X 是偶数，而 Y 是奇数，那么它们就是 “Zamn”。
现在给定一个大小为 N 的数组 A，其中每个元素的编号从 0 到 N-1。你需要计算所有的三元组 (i, j, k)，其中 i < j < k，并且 (A[i], A[j]) 和 (A[j], A[k]) 都是 “Zamn” 关系。
这些三元组被称为 “Zamn” 三元组，你的任务是计算给定数组中所有的 “Zamn” 三元组的数量，并返回结果。
例如：当 N = 4 且 A = [1, 2, 5, 4] 时，数组中的 Zamn 三元组是 (0, 1, 2) 和 (1, 2, 3)，因此计数等于 2。
def solution(N: int, A: list) -> int:
count = 0
# 遍历所有可能的三元组 (i, j, k)
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
# 检查 (A[i], A[j]) 和 (A[j], A[k]) 是否都是 "Zamn" 关系
if (A[i] % 2 != A[j] % 2) and (A[j] % 2 != A[k] % 2):
count += 1
return count
if __name__ == '__main__':
print(solution(N = 4, A = [1, 2, 5, 4]) == 2)
print(solution(N = 5, A = [3, 6, 1, 8, 7]) == 5)
print(solution(N = 6, A = [2, 3, 4, 5, 6, 7]) == 8)
试题4：三国示例划分问题
问题描述：
小C在一个大小为 n * m 的棋盘状土地上发现了三个国家的势力分布s。每个格子上都有一个数字，表示该格子的归属国家。上下左右相邻且属于同一个国家的格子被认为是同一股势力。现在小C想知道，这片土地上总共有多少股不同的势力。
你需要编写一个程序来计算土地上总共的势力股数。
def solution(n, m, s):
# 创建一个二维数组来表示棋盘
board = [list(row) for row in s]
# 定义一个函数来进行深度优先搜索
def dfs(x, y, country):
# 如果越界或者当前格子不属于当前国家，返回
if x < 0 or x >= n or y < 0 or y >= m or board[x][y] != country:
return
# 标记当前格子为已访问
board[x][y] = '#'
# 递归访问上下左右四个方向
dfs(x - 1, y, country)
dfs(x + 1, y, country)
dfs(x, y - 1, country)
dfs(x, y + 1, country)
# 初始化势力股数
count = 0
# 遍历整个棋盘
for i in range(n):
for j in range(m):
# 如果当前格子是一个新的国家，进行DFS并增加势力股数
if board[i][j] != '#':
count += 1
dfs(i, j, board[i][j])
return count
if __name__ == '__main__':
print(solution(n = 4, m = 4, s = ["1122", "1222", "3111", "3333"]) == 4)
print(solution(n = 2, m = 2, s = ["11", "11"]) == 1)
print(solution(n = 3, m = 3, s = ["123", "123", "123"]) == 3)
试题5：三枚石子的最少移动问题
问题描述：
小U在数轴上放置了三枚石子，位置分别是 a, b, c。在每一回合中，小U可以选择从最左边或最右边的石子，并将其移动到它们中间的某个空闲位置。目标是使得三枚石子的位置连续，即不能再进行任何移动。你需要帮助小U找到游戏结束所需的最大移动次数。
def solution(a: int, b: int, c: int) -> int:
# 1. 对三个位置进行排序
positions = sorted([a, b, c])
# 2. 计算中间位置和两端位置之间的空位数
# 空位数 = (positions[2] - positions[1] - 1) + (positions[1] - positions[0] - 1)
empty_slots = (positions[2] - positions[1] - 1) + (positions[1] - positions[0] - 1)
# 3. 计算最大移动次数
# 最大移动次数 = 空位数
max_moves = empty_slots
return max_moves
if __name__ == '__main__':
print(solution(a=1, b=2, c=5) == 2)
print(solution(a=4, b=3, c=2) == 0)
print(solution(a=3, b=5, c=1) == 2)
试题6：不同子串的排序问题
问题描述：
小R对字符串的子串非常感兴趣，特别是关于所有不同的子串。他有一个字符串s，想知道其中第k小的不同子串是什么。小R希望你能帮他找到答案。如果第k小的子串不存在，则返回NO ANSWER。
例如，给定字符串s = “aab”，我们可以列出所有不同的子串，并按字典序排序。小R想知道排在第k小的子串是什么。
def solution(s: str, k: int) -> str:
# 1. 生成所有不同的子串
substrings = set()
for i in range(len(s)):
for j in range(i + 1, len(s) + 1):
substrings.add(s[i:j])
# 2. 将子串按字典序排序
sorted_substrings = sorted(substrings)
# 3. 查找第k小的子串
if k <= len(sorted_substrings):
return sorted_substrings[k - 1]
else:
return "NO ANSWER"
if __name__ == '__main__':
print(solution("aab", 4) == 'ab')
print(solution("abc", 6) == 'c')
print(solution("banana", 10) == 'banan')
试题7：二进制子字符串覆盖问题
问题描述：
小M有一个二进制字符串 s，以及一个正整数 n。小M想知道，对于 [1, n] 范围内的每个整数，其二进制表示是否都是字符串 s 的某个子字符串。一个子字符串是字符串中的连续字符序列。
如果 s 包含 [1, n] 范围内每个整数的二进制表示，返回 true，否则返回 false。
def solution(s: str, n: int) -> bool:
# 遍历 [1, n] 范围内的每个整数
for i in range(1, n + 1):
# 将整数转换为二进制字符串，并去掉前缀 '0b'
binary_str = bin(i)[2:]
# 检查 binary_str 是否是 s 的子字符串
if s.find(binary_str) == -1:
return False
# 如果所有二进制表示都是 s 的子字符串，返回 True
return True
if __name__ == '__main__':
print(solution(s="0110", n=3) == True)
print(solution(s="1001", n=4) == False)
print(solution(s="1100101", n=6) == True)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
