青训营-豆包MarsCode技术训练营试题解析四十一

引言

随着AI领域的发展，底层算法确实起到了决定性的作用。为了跟上这个快速发展的领域，我们需要不断学习和提升自己的技能。刷题是一种很好的方式，可以帮助我们巩固基础知识，提高解决问题的能力。

介绍

‌豆包青训营‌是由字节跳动和稀土掘金社区共同发起的技术培训和人才选拔项目。该项目的目标是培养具有职业竞争力的优秀开发工程师，并提供全程免费的课程，不收取任何费用‌。

课程内容和方向

豆包青训营的课程涵盖前端、后端和AI方向。在这个飞速发展的AI时代，学员将与豆包MarsCode团队一起深入探索技术领域，学习和运用AI，提高编程效率‌。此外，课程还包括大数据方向，适合对大数据感兴趣的学员学习‌，

本文提供训练营试题解析供参考

试题1：单人资源收集游戏的最高得分

问题描述：

给定三个资源堆，大小分别为 a、b 和 c。每回合可以从 两个不同的非空堆 中各取出一个资源，得分加 1 分。游戏在两个或更多的堆变为空时结束。计算游戏中可以获得的最大得分。

def solution(a: int, b: int, c: int) -> int:
    # 将三个堆按大小排序，确保 a <= b <= c
    a, b, c = sorted([a, b, c])
    
    # 初始化得分
    score = 0
    
    # 贪心策略：每次从最大的两个堆中各取一个资源
    while b > 0 and c > 0:
        # 从 b 和 c 中各取一个资源
        b -= 1
        c -= 1
        score += 1
        
        # 重新排序，确保 a <= b <= c
        a, b, c = sorted([a, b, c])
    
    # 返回最大得分
    return score

if __name__ == '__main__':
    print(solution(a=3, b=5, c=6) == 7)
    print(solution(a=2, b=9, c=9) == 10)
    print(solution(a=5, b=5, c=8) == 9)

试题2：双数配对策略

问题描述：

给定一个整数数组 a，你需要找出能够形成的最大对数，条件是每对数的和必须等于 k。每个数字只能使用一次，你可以选择任意数量的数对。你的任务是计算出可以选择的数对数量。

from typing import List

def solution(a: List[int], k: int) -> int:
    # 使用字典记录每个数字的出现次数
    count_map = {}
    # 记录可以形成的对数数量
    pair_count = 0
    
    for num in a:
        # 计算当前数字的补数
        complement = k - num
        
        # 检查补数是否在字典中
        if complement in count_map and count_map[complement] > 0:
            # 如果存在，形成一对，减少补数的计数
            pair_count += 1
            count_map[complement] -= 1
        else:
            # 如果不存在，将当前数字加入字典
            if num in count_map:
                count_map[num] += 1
            else:
                count_map[num] = 1
    
    return pair_count

if __name__ == '__main__':
    print(solution(a=[2, 3, 5, 6], k=7) == 1)
    print(solution(a=[4, 2, 4, 5, 4], k=8) == 1)
    print(solution(a=[2, 4, 2, 4, 2], k=6) == 2)

试题3：古老硬币位置统一代价问题

问题描述：

小M 正在研究一种古老硬币的移动问题，现有 n 个硬币，每个硬币的初始位置保存在数组 locations 中。他希望将所有硬币移动到同一个位置。

移动硬币的规则如下：

小M 可以将第 i 个硬币从位置 locations[i] 移动到 locations[i] + 2 或 locations[i] - 2，这不会产生任何费用（cost = 0）。

小M 可以将第 i 个硬币从位置 locations[i] 移动到 locations[i] + 1 或 locations[i] - 1，这将产生 1 单位的费用（cost = 1）。

你的任务是帮助小M 找到将所有硬币移动到同一位置所需的最小费用。

from typing import List

def solution(locations: List[int]) -> int:
    min_cost = float('inf')  # 初始化最小费用为一个很大的值
    
    # 遍历所有可能的目标位置
    for target in range(min(locations), max(locations) + 1):
        current_cost = 0
        
        # 计算所有硬币移动到目标位置的总费用
        for loc in locations:
            # 计算当前硬币移动到目标位置的费用
            # 这里需要根据移动规则计算费用
            # 如果距离是偶数，费用为0；如果距离是奇数，费用为1
            distance = abs(loc - target)
            if distance % 2 == 0:
                current_cost += 0
            else:
                current_cost += 1
        
        # 更新最小费用
        if current_cost < min_cost:
            min_cost = current_cost
    
    return min_cost

if __name__ == '__main__':
    print(solution(locations=[2, 3, 5, 7]) == 1)
    print(solution(locations=[1, 1, 2, 3, 4]) == 2)
    print(solution(locations=[2, 4, 6, 6]) == 0)

试题4：四因数的数字和问题

问题描述：

小C和小U正在研究一组数字组成的数组，他们发现其中有一些数字拥有恰好四个不同的因数。为了更好地了解这些数字的性质，他们希望计算出这些数字的所有因数之和。具体来说，你需要帮小C和小U找出数组中拥有四个因数的数字，并计算这些因数的总和。

你需要帮助他们计算所有符合条件的数字的因数总和。如果没有找到符合条件的数字，则返回 0。

from typing import List

def solution(nums: List[int]) -> int:
    # 辅助函数：计算一个数的因数个数和因数之和
    def get_factors_info(n: int) -> (int, int):
        count = 0
        total_sum = 0
        for i in range(1, n + 1):
            if n % i == 0:
                count += 1
                total_sum += i
        return count, total_sum
    
    result = 0
    
    # 遍历输入数组
    for num in nums:
        # 获取当前数的因数个数和因数之和
        count, total_sum = get_factors_info(num)
        
        # 判断因数个数是否为4
        if count == 4:
            # 累加符合条件的数的因数之和
            result += total_sum
    
    # 返回最终结果
    return result

if __name__ == '__main__':
    print(solution(nums=[25, 30, 12]) == 0)
    print(solution(nums=[15, 6, 10]) == 54)
    print(solution(nums=[10, 21, 14]) == 74)

试题5：团队的最高得分问题

问题描述：

小L 需要为一场大型项目组建一个团队，每个成员都有一个技能值和经验值，团队的总技能值等于所有成员技能值的总和。为了避免团队成员之间的分歧，团队需要满足以下条件：

1、如果一个经验较少的成员拥有的技能值比一个经验丰富的成员高，则两者之间会产生分歧。同等经验的成员不会产生分歧。

2、小L 的目标是组建一个无分歧的团队，并使团队的总技能值尽可能高。

给定两个数组 skills 和 experience，其中 skills[i] 和 experience[i] 分别表示第 i 个成员的技能值和经验值。你的任务是找出符合条件的团队，使其总技能值达到最大，即计算最大化的总和满足：对于任意成员 i 和 j，当 experience[i] < experience[j] 时，需满足 skills[i] <= skills[j]。

from typing import List

def solution(skills: List[int], experience: List[int]) -> int:
    # 1. 将成员按照经验值进行排序
    # 2. 使用动态规划计算最大技能值
    # 3. 返回最大技能值
    
    # 将成员按照经验值进行排序
    members = sorted(zip(experience, skills))
    
    # 初始化动态规划数组
    dp = [0] * len(members)
    
    # 遍历每个成员
    for i in range(len(members)):
        # 初始化当前成员的技能值
        dp[i] = members[i][1]
        
        # 遍历之前的成员，更新当前成员的最大技能值
        for j in range(i):
            if members[j][1] <= members[i][1]:
                dp[i] = max(dp[i], dp[j] + members[i][1])
    
    # 返回最大技能值
    return max(dp)

if __name__ == '__main__':
    print(solution(skills=[2, 4, 6, 8, 10], experience=[3, 4, 5, 6, 7]) == 30)
    print(solution(skills=[3, 6, 9, 7], experience=[2, 3, 2, 1]) == 16)
    print(solution(skills=[5, 5, 3, 7], experience=[2, 1, 3, 2]) == 17)
    print(solution(skills=[4, 9, 8], experience=[3, 1, 2]) == 9)