实践记录以及工具使用 1 | 豆包MarsCode AI刷题

用户87917148336
109 阅读5分钟

最近，我在学习Java和算法时，遇到了一道迷宫问题，题目要求通过最少的黑色格子到达迷宫的终点。起初，我对该问题的解决方案没有明确的思路，想到的暴力方法一下就超过了允许的时间复杂度，并且我没办法独自思考出剪枝方案，但通过使用豆包MarsCode AI，我不仅成功解决了这个问题，还深入理解了BFS算法在此类问题中的应用。

本文档记录通过豆包MarsCode AI学会解决“最少黑色格子数迷宫问题”，并借助此题总结使用豆包MarsCode AI的学习过程，重点分析其功能亮点，并分享我在刷题实践中的收获。

豆包MarsCode AI的功能亮点

豆包MarsCode AI具有许多功能，其中几个亮点特别帮助了我在编程学习中取得进展：

1. 精选真题库

豆包MarsCode AI为学习者提供了一个精选的题库，其中包括大量来自真实面试的算法题目。每个问题的难度、类型和知识点都经过精心挑选，非常适合我在不同阶段的学习需求。

通过系统地刷这些精选题目，我积累了广泛的算法知识，熟悉了多种编程技巧，为实际面试做好准备。在学习这道“最少黑色格子数迷宫问题”时，类似的问题让我了解了BFS（广度优先搜索）算法的应用，为解决当前问题提供了有力支持。

2. 智能云端编辑器

豆包MarsCode AI配备了一个云端编辑器，允许用户在线编写、调试和运行代码。这不仅消除了环境配置的麻烦，还能让用户随时随地进行学习和练习。

在解决迷宫问题时，我通过云端编辑器实时编写代码并进行测试，能够快速验证自己的思路是否正确。这种即写即跑的功能提高了我的学习效率，避免了繁琐的本地环境配置和调试过程。

3. 自动化代码优化与提示

在编写代码时，豆包MarsCode AI会根据用户的代码提供优化建议。它不仅能指出可能存在的错误，还能帮助优化算法的性能。

在编写BFS算法时，我遇到了代码性能优化的问题。豆包MarsCode AI通过分析我的代码，建议我使用更高效的数据结构（如Queue）来进行队列操作，帮助我提升了代码的效率。

刷题实践

问题描述

题目要求在一个n×m的迷宫中找到一条从左上角到右下角的路径，并且路径上经过的黑色格子尽量少。迷宫的每个格子可以是黑色（1）或者白色（0），我们可以上下左右移动，但不能越过边界。

解题思路

这道题目可以通过广度优先搜索（BFS） 来解决。BFS适合用于最短路径问题，在本题中，BFS可以帮助我们从起点出发，按层次逐步遍历迷宫，寻找经过黑色格子最少的路径。我们用一个二维数组dist来记录每个位置到达时经过的黑色格子数量。初始化dist数组为Integer.MAX_VALUE，表示未访问过的格子。使用一个队列来进行BFS，每次从队列中取出一个当前格子的位置，然后遍历其四个相邻的格子。当我们访问到一个相邻格子时，计算经过该格子的黑色数量，如果该路径的黑色格子数比当前记录的少，就更新dist数组，并将该格子加入队列。当队列空时，返回右下角格子的最少黑色格子数量。如果无法到达，则返回-1。

实际代码

package JuejinAiCodes;

import java.util.LinkedList;
import java.util.Queue;

public class BWZone {
    // 方向数组，分别表示上下左右四个方向
    private static final int[] dx = {-1, 1, 0, 0};
    private static final int[] dy = {0, 0, -1, 1};

    public static int solution(int n, int m, int[][] grid) {
        // 用一个二维数组记录每个格子到达时的最小黑色格子数
        int[][] dist = new int[n][m];

        // 初始化dist数组为无穷大，表示尚未访问
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dist[i][j] = Integer.MAX_VALUE;
            }
        }

        // 队列存储当前格子的坐标和黑色格子数量
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});
        dist[0][0] = grid[0][0];  // 起点的黑色格子数量

        // BFS
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int x = current[0], y = current[1];

            // 遍历四个方向
            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];

                // 判断新的位置是否在迷宫内
                if (nx >= 0 && nx < n && ny >= 0 && ny < m) {
                    // 计算经过当前格子的黑色格子数
                    int newDist = dist[x][y] + grid[nx][ny];

                    // 如果通过当前格子的路径比之前记录的路径更少黑色格子，更新dist数组
                    if (newDist < dist[nx][ny]) {
                        dist[nx][ny] = newDist;
                        queue.add(new int[]{nx, ny});
                    }
                }
            }
        }

        // 返回右下角的最小黑色格子数
        return dist[n-1][m-1] == Integer.MAX_VALUE ? -1 : dist[n-1][m-1];
    }

    public static void main(String[] args) {
        System.out.println(solution(5, 3, new int[][]{{0, 1, 0}, {0, 1, 1}, {0, 1, 0}, {1, 0, 0}, {1, 0, 0}}) == 1);
        System.out.println(solution(4, 4, new int[][]{{0, 0, 1, 0}, {1, 0, 1, 0}, {1, 0, 0, 0}, {1, 1, 1, 0}}) == 0);
        System.out.println(solution(3, 3, new int[][]{{0, 0, 0}, {1, 1, 0}, {1, 1, 0}}) == 0);
    }
}
avatar
文章
阅读
粉丝