青训营刷题实践：总结 AI 刷题的优势与学习路径分析 | 豆包MarsCode AI刷题

用户33102981138
154 阅读11分钟

在算法学习中，刷题一直是被广泛推荐的一种学习方式。通过大量的题目实践，我们不仅能够积累解决问题的经验，还能加深对算法与数据结构的理解。近年来，随着人工智能技术的发展，AI 助手在刷题过程中逐渐成为了学习的得力助手。通过与 AI 的互动，不仅能快速获得算法题目的解题思路，还能在调试过程中获得有价值的代码优化建议，甚至在面对困难时，AI 能提供定制化的思路与解释，帮助我更高效地学习。

本文将通过我刷题过程中的一些具体案例，来分析 AI 在算法学习中的优势，并分享 AI 如何帮助我提高解题能力，优化学习路径，提升效率。

AI 助力刷题的优势

1. 提供解题思路和算法框架

刷题不仅仅是解决题目，更重要的是在解决问题的过程中形成对算法和数据结构的深刻理解。传统的刷题方法，通常依赖于自己对题目分析，往往需要反复修改和调试，甚至有时会陷入思路的瓶颈。而 AI 助手可以根据题目描述，快速提炼出解题的核心思路，并帮助我们搭建合适的算法框架，从而避免无效的思考和多余的调试。

例如在下面的题目中，AI 能够迅速提供出合理的解题思路：

题目： 从一个点 ss 到另一个点 tt，在点集之间的路径被删除，求从 ss 到 tt 的最短路径（Dijkstra）。

AI 提供的解题思路： AI 自动分析了题目要求，并建议使用 Dijkstra 算法来计算最短路径。在此基础上，AI 提出了删除路径的约束条件，并给出了需要排除的路径（即 ss 到 tt 之间的直接路径）。AI 进一步细化了如何在 Dijkstra 算法的基础上处理这些限制条件，并确保每个点之间的距离计算正确。

这种自动分析和框架构建的能力，帮助我迅速进入解题状态，而不需要消耗过多时间在思考解题思路的阶段。

2. 快速调试和代码优化建议

在解题过程中，尤其是面对复杂的题目和边界情况时，我们可能会陷入调试的困境。很多时候，调试会涉及到细节上的错误，比如数组越界、边界条件处理不当、数据类型转换不一致等问题。AI 不仅能够快速找到问题，还能提供优化建议。

以下面的题目为例：

题目： 给定一个二维平面上的 nn 个点，求从起点 ss 到终点 tt 的最短路径，不能直接通过被删除的路径。请计算最短路径并四舍五入保留两位小数。

AI 在代码调试中的应用： 当我编写了 Dijkstra 算法并测试时，AI 提供了对代码的逐步分析，指出了我在处理“删除的路径”的条件判断上存在的问题。在原始代码中，我未能正确标记从 ss 到 tt 的路径，这导致计算的最短路径结果不正确。AI 提示了应该如何在 Dijkstra 算法中加入“删除路径”的条件判断，并给出了修正代码。

通过 AI 的帮助，我不仅快速找到了问题，还学会了如何在 Dijkstra 算法中动态处理路径约束，避免了重复错误。

3. 定制化学习与深入剖析

AI 能够根据我的学习进度和问题，定制化地提供解题建议、优化技巧以及相关算法的详细解析。这种针对性的学习方式，帮助我在学习过程中更加高效，避免了碎片化的学习进程。

在我的实践中，当我遇到一些难题时，AI 会不仅仅提供一个简单的解答，而是从算法的本质进行深入剖析，帮助我理解每个步骤的背后原理。例如，在处理某些特定算法时，AI 会通过图解的方式将其解题思路可视化，从而让我更好地理解其本质。

具体案例：AI 在算法学习中的应用

案例 1：图论中的最短路径问题

问题描述： 我们在一个地图上有 nn 个点，每个点的坐标已经给定，要求计算从起点 ss 到终点 tt 的最短路径，但需要注意，起点和终点之间的直接路径已经删除。

思路分析： 在这个问题中，我们需要处理删除的路径约束。AI 提供的 Dijkstra 算法框架，建议在实现 Dijkstra 时，对每一条边都做判断，若该边是被删除的边，则跳过该边。在此基础上，我们可以继续计算最短路径。

通过与 AI 互动，我逐步拆解并优化了我的代码。以下是如何一步一步与 AI 一起调试代码的详细过程：

确定代码框架

在解题的第一步，我和 AI 一起确定了基本的代码框架。根据题目的要求，我们首先明确了所需要的算法：Dijkstra 算法。此算法用于在加权图中找到单源点到其他所有点的最短路径。针对本题，由于有删除路径的约束条件，我们还需要在计算过程中排除某些不允许的路径。

在与 AI 的互动中，我们确定了以下框架：

  1. 计算两点间的欧几里得距离，这需要我们根据点的坐标计算出两点间的距离。
  2. 构建邻接矩阵，表示所有点之间的距离关系。
  3. 实现 Dijkstra 算法，并在其中排除被删除的路径。

以下是确定的代码框架：

def solution(n: int, s: int, t: int, x: list, y: list) -> str:
    # 计算两点之间的欧几里得距离
    def calculate_distance(x1, y1, x2, y2):
        # ...计算两点之间的欧几里得距离
        return distance

    # 构建邻接矩阵
    # ...构建邻接矩阵

    # Dijkstra算法实现
    def dijkstra(start, end):
        # ...Dijkstra算法实现

    return ""

    if __name__ == '__main__':
    print(solution(5, 1, 5, [17253, 25501, 28676, 30711, 18651], [15901, 15698, 32041, 11015, 9733]) == '17333.65')
    print(solution(4, 2, 4, [5000, 12000, 8000, 14000], [3000, 9000, 1000, 4000]) == '15652.48')
    print(solution(6, 3, 6, [20000, 22000, 24000, 26000, 28000, 30000], [15000, 13000, 11000, 17000, 19000, 21000]) == '11772.70')

思考与分析：

  1. 问题： 在此阶段，我们没有考虑“删除路径”约束，也没有优化最短路径计算中需要排除的特殊情况。
  2. 分析： AI 提供的框架已经搭建完成，但对于路径删除的约束条件，仍需进一步优化。

问题分析

当我运行代码时，发现某些测试用例未能通过，特别是在删除路径的情况下，代码未能正确排除这些路径。例如，测试用例：

solution(5, 1, 5, [17253, 25501, 28676, 30711, 18651], [15901, 15698, 32041, 11015, 9733])

给出的结果与预期值 17333.65 不符。

思考与分析： 在 Dijkstra 中，我使用了一个判断条件 (curr == s - 1 and next_node == t - 1)，它仅检测了从 ss 到 tt 的直接路径，但没有完全考虑到删除路径可能带来的影响。在某些边的处理上，可能会误判。

豆包 MarsCode 的优化建议

豆包 MarsCode 提示：在 Dijkstra 算法中，必须更细致地处理删除路径的问题。

AI 优化的地方： AI 在我第一次实现代码时，提到在 Dijkstra 算法中，必须仔细检查起点和终点之间的路径约束条件（即被删除的路径）。此外，AI 还提醒我在 Dijkstra 过程中，应该将每个相邻节点的距离更新逻辑实现得更加严谨，避免错误的路径更新。

思考： 通过 AI 的指导，我发现删除路径的处理比我最初想象的要复杂。这个过程不仅仅是跳过某个边的计算，而是要在每一条边的更新过程中，都保证删除的边不被使用。这一细节提醒我，实际的图算法不仅需要考虑路径的长度，还需要处理复杂的约束条件。

案例 2：字符串处理中的操作最小化问题

问题描述： 给定一个包含字符 0 和 1 的字符串，你可以进行最多 kk 次操作，目标是将字符串中的 1 移到 0 的前面，求最小操作次数。

思路分析： 这个问题的核心是如何通过最少的交换操作，确保字符 1 出现在字符 0 之前。AI 提供了贪心策略，并建议从左到右遍历字符串，对于每个字符 1，寻找最靠近的字符 0 进行交换，从而实现最小交换。

确定代码框架

我们要处理的字符串是由字符 0 和 1 构成，我们的任务是将所有 1 移到所有 0 的前面。允许的操作是每次将一个 1 向左移动，最多进行 k 次操作。

对于这个问题，我们可以采取贪心算法来解决：

  1. 贪心策略：我们尝试将每个 1 移动到它最前面的空位。
  2. 操作计算：每次计算一个 1 移动到目标位置需要多少次操作（即交换次数）。
  3. 操作次数限制：如果操作次数超过了 k，我们停止。

首先，我们需要一个函数来处理字符串，并根据给定的操作次数 k 来调整字符串。

def solution(n: int, k: int, s: str) -> str:
    s = list(s)  # 将字符串转换为列表以便操作
    for i in range(n):
        if k <= 0:
            break  # 如果没有剩余的操作次数，退出
        
        if s[i] == '0':
            continue  # 如果当前字符是 '0'，则无需移动
        
        # 需要将字符 '0' 移到当前位置 i 之前
        # 我们寻找能用来替换当前 '1' 的最小的 '0'
        for j in range(i + 1, n):
            if s[j] == '0':
                # 计算需要的交换次数
                needed_swaps = j - i
                if needed_swaps <= k:
                    # 执行交换
                    for swap in range(j, i, -1):
                        s[swap], s[swap - 1] = s[swap - 1], s[swap]
                    k -= needed_swaps  # 减少可用的交换次数
                break  # 找到一个 '0' 之后就可以退出内层循环

    return ''.join(s)

思考与分析：

  1. 字符串转为列表：s = list(s) 用于将输入的字符串转换为列表，因为字符串在 Python 中是不可变的，而列表是可变的。
  2. 遍历字符串：for i in range(n) 遍历字符串中的每个字符。
  3. 操作次数限制：通过 if k <= 0: break 判断是否已经耗尽操作次数。
  4. 交换逻辑：内层的 for j in range(i + 1, n) 寻找一个 0，然后计算需要多少次交换才能将 0 移动到当前 1 的前面。

豆包 MarsCode 分析与优化

问题1：内层循环可能重复进行无用操作
在内层 for 循环中，一旦找到了一个 0 并且完成交换，就退出了循环。但如果剩余的操作次数不够，代码将会执行无意义的交换。我们可以优化这部分逻辑，以确保每次交换前都检查剩余操作次数是否足够。

问题2：交换过程的效率
每次交换时，我们使用了 for swap in range(j, i, -1) 来反复交换元素。这种方法的效率较低，可能会导致时间复杂度较高。我们可以通过其他方法减少交换次数，或者通过数学推导直接计算交换次数。

基于上述问题，我对代码进行了优化，特别是减少了不必要的交换操作，并且避免了冗余的计算。

def solution(n: int, k: int, s: str) -> str:
    s = list(s)
    for i in range(n):
        if k <= 0:
            break
        
        if s[i] == '0':
            continue
        
        for j in range(i + 1, n):
            if s[j] == '0':
                needed_swaps = j - i
                if needed_swaps <= k:
                    # 直接计算需要交换的次数，并执行一次交换
                    s[i], s[j] = s[j], s[i]
                    k -= needed_swaps
                break

    return ''.join(s)

总结

通过与 AI 互动，我的刷题过程变得更加高效、精准。在解题思路、代码优化和学习路径方面，AI 都提供了巨大帮助。尤其是在遇到困难或瓶颈时，AI 的个性化建议和专业分析使我能够快速调整学习策略，避免重复错误，深入理解每个问题的本质。AI 的优势在于它不仅仅是一个工具，更是一个得力的学习伙伴，帮助我从根本上提高算法与数据结构的学习效率。

通过本案例，我希望能够启发更多刷题者，借助 AI 提供的解题思路和反馈，更加高效地提升自己的算法能力。

avatar
文章
阅读
粉丝