LeetCode-寻宝

最新推荐文章于 2024-06-02 15:01:15 发布
最新推荐文章于 2024-06-02 15:01:15 发布
阅读量500 收藏 1
点赞数
分类专栏： 算法 LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yshuoo/article/details/107676699
版权

这个题完全没有思路，只能看题解了：

class Solution {
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};
    int n, m;

    public int minimalSteps(String[] maze) {
        n = maze.length;
        m = maze[0].length();
        // 机关 & 石头
        List<int[]> buttons = new ArrayList<int[]>();
        List<int[]> stones = new ArrayList<int[]>();
        // 起点 & 终点
        int sx = -1, sy = -1, tx = -1, ty = -1;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (maze[i].charAt(j) == 'M') {
                    buttons.add(new int[]{i, j});
                }
                if (maze[i].charAt(j) == 'O') {
                    stones.add(new int[]{i, j});
                }
                if (maze[i].charAt(j) == 'S') {
                    sx = i;
                    sy = j;
                }
                if (maze[i].charAt(j) == 'T') {
                    tx = i;
                    ty = j;
                }
            }
        }
        int nb = buttons.size();
        int ns = stones.size();
        int[][] startDist = bfs(sx, sy, maze);

        // 边界情况：没有机关
        if (nb == 0) {
            return startDist[tx][ty];
        }
        // 从某个机关到其他机关 / 起点与终点的最短距离。
        int[][] dist = new int[nb][nb + 2];
        for (int i = 0; i < nb; i++) {
            Arrays.fill(dist[i], -1);
        }
        // 中间结果
        int[][][] dd = new int[nb][][];
        for (int i = 0; i < nb; i++) {
            int[][] d = bfs(buttons.get(i)[0], buttons.get(i)[1], maze);
            dd[i] = d;
            // 从某个点到终点不需要拿石头
            dist[i][nb + 1] = d[tx][ty];
        }

        for (int i = 0; i < nb; i++) {
            int tmp = -1;
            for (int k = 0; k < ns; k++) {
                int midX = stones.get(k)[0], midY = stones.get(k)[1];
                if (dd[i][midX][midY] != -1 && startDist[midX][midY] != -1) {
                    if (tmp == -1 || tmp > dd[i][midX][midY] + startDist[midX][midY]) {
                        tmp = dd[i][midX][midY] + startDist[midX][midY];
                    }
                }
            }
            dist[i][nb] = tmp;
            for (int j = i + 1; j < nb; j++) {
                int mn = -1;
                for (int k = 0; k < ns; k++) {
                    int midX = stones.get(k)[0], midY = stones.get(k)[1];
                    if (dd[i][midX][midY] != -1 && dd[j][midX][midY] != -1) {
                        if (mn == -1 || mn > dd[i][midX][midY] + dd[j][midX][midY]) {
                            mn = dd[i][midX][midY] + dd[j][midX][midY];
                        }
                    }
                }
                dist[i][j] = mn;
                dist[j][i] = mn;
            }
        }

        // 无法达成的情形
        for (int i = 0; i < nb; i++) {
            if (dist[i][nb] == -1 || dist[i][nb + 1] == -1) {
                return -1;
            }
        }
        
        // dp 数组， -1 代表没有遍历到
        int[][] dp = new int[1 << nb][nb];
        for (int i = 0; i < 1 << nb; i++) {
            Arrays.fill(dp[i], -1);
        }
        for (int i = 0; i < nb; i++) {
            dp[1 << i][i] = dist[i][nb];
        }
        
        // 由于更新的状态都比未更新的大，所以直接从小到大遍历即可
        for (int mask = 1; mask < (1 << nb); mask++) {
            for (int i = 0; i < nb; i++) {
                // 当前 dp 是合法的
                if ((mask & (1 << i)) != 0) {
                    for (int j = 0; j < nb; j++) {
                        // j 不在 mask 里
                        if ((mask & (1 << j)) == 0) {
                            int next = mask | (1 << j);
                            if (dp[next][j] == -1 || dp[next][j] > dp[mask][i] + dist[i][j]) {
                                dp[next][j] = dp[mask][i] + dist[i][j];
                            }
                        }
                    }
                }
            }
        }

        int ret = -1;
        int finalMask = (1 << nb) - 1;
        for (int i = 0; i < nb; i++) {
            if (ret == -1 || ret > dp[finalMask][i] + dist[i][nb + 1]) {
                ret = dp[finalMask][i] + dist[i][nb + 1];
            }
        }

        return ret;
    }

    public int[][] bfs(int x, int y, String[] maze) {
        int[][] ret = new int[n][m];
        for (int i = 0; i < n; i++) {
            Arrays.fill(ret[i], -1);
        }
        ret[x][y] = 0;
        Queue<int[]> queue = new LinkedList<int[]>();
        queue.offer(new int[]{x, y});
        while (!queue.isEmpty()) {
            int[] p = queue.poll();
            int curx = p[0], cury = p[1];
            for (int k = 0; k < 4; k++) {
                int nx = curx + dx[k], ny = cury + dy[k];
                if (inBound(nx, ny) && maze[nx].charAt(ny) != '#' && ret[nx][ny] == -1) {
                    ret[nx][ny] = ret[curx][cury] + 1;
                    queue.offer(new int[]{nx, ny});
                }
            }
        }
        return ret;
    }

    public boolean inBound(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}

 这个题解我觉得好理解一点

    // 起点与终点，统计所有的石头和机关的坐标
    Point startPoint = null;
    Point endPoint = null;
    List<Point> stones = new ArrayList<>();
    List<Point> triggers = new ArrayList<>();

    // java 为了看的方便起见, string maze -> matrix
    char[][] mat = new char[n][m];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            mat[i][j] = maze[i].charAt(j);
        }
    }
    // init maze
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mat[i][j] == 'S') {
                startPoint = new Point(i, j);
                mat[i][j] = '.';
                continue;
            }
            if (mat[i][j] == 'T') {
                endPoint = new Point(i, j);
                mat[i][j] = '.';
                continue;
            }
            if (mat[i][j] == 'O') {
                stones.add(new Point(i, j));
                mat[i][j] = '.';
                continue;
            }
            if (mat[i][j] == 'M') {
                triggers.add(new Point(i, j));
                mat[i][j] = '.';
            }
        }
    }
    // 原本是: 起点(S) -> 石堆 -> 机关 -> 石堆 -> 机关 ... -> 石堆 -> 机关 -> 终点(T)
    // 为了方便, 把起点认为是机关, 终点认为是石堆, 比较方便
    // 就变为: 机关(S) -> 石堆 -> 机关 -> 石堆 -> 机关 ... -> 石堆 -> 机关 -> 石堆(T)
    triggers.add(startPoint);
    stones.add(endPoint);

 2. 计算点与点之间的距离--BFS

    /**
     * BFS: 从给定起点到给定终点最少需要走多少步
     *
     * @param from 起点
     * @param to   终点
     * @return 步数
     */
    private int bfs(Point from, Point to, char[][] maze) {
        // 特判: 如果是墙壁, 返回 -1
        if (maze[from.x][from.y] == '#') {
            return -1;
        }
        // 初始化 dist 数组
        for (int[] a : dist) {
            Arrays.fill(a, -1);
        }
        queue.offer(from);
        dist[from.x][from.y] = 0;

        while (!queue.isEmpty()) {
            Point cur = queue.poll();
            int x = cur.x;
            int y = cur.y;
            for (int i = 0; i < 4; i++) {
                int nx = x + dir[i];
                int ny = y + dir[i + 1];
                if (nx < 0 || nx >= n || ny < 0 || ny >= m || maze[nx][ny] == '#') continue;
                if (dist[nx][ny] == -1) {
                    dist[nx][ny] = dist[x][y] + 1;
                    queue.offer(new Point(nx, ny));
                }
            }
        }
        return dist[to.x][to.y];
    }

 3. 计算 tsDist 数组与 ttDist 数组

    // tsDist[][] : trigger to stone dist，机关到石头的最短距离
    // ttDist[][] : trigger to trigger dist，机关到机关的最短距离

    int p = stones.size() - 1;
    int q = triggers.size() - 1;

    // 初始化 tsDist 数组: 计算任意一个机关(trigger) i 到任意一个石堆(stone) j 的距离
    for (int i = 0; i <= q; i++) {
        for (int j = 0; j <= p; j++) {
            tsDist[i][j] = bfs(triggers.get(i), stones.get(j), mat);
        }
    }

    // 初始化 ttDist 数组: 当前位于第 i 个机关，下一步要开启第 j 个机关，最少要走多少步
    // 即第 i 个机关走向某个石堆 k，再从该石堆走向机关 j 的步数, floyd
    for (int i = 0; i <= q; i++) {
        for (int j = 0; j <= q; j++) {
            ttDist[i][j] = INF;
            // 枚举石堆, 不算终点
            for (int k = 0; k < p; k++) {
                if (tsDist[i][k] == -1 || tsDist[j][k] == -1) continue;
                int cost = tsDist[i][k] + tsDist[j][k];
                ttDist[i][j] = Math.min(ttDist[i][j], cost);
            }
        }
    }

 

    // 初始化 dp 数组
    for (int[] a : f) {
        Arrays.fill(a, -1);
    }
    // 起点就是第q个机关，此时所有机关都是关着的，status 为 0，最少需要 0 步
    f[q][0] = 0;

    // 枚举机关所有状态 staus
    int lim = 1 << q;
    for (int s = 0; s < lim; s++) {
        // 枚举位于第 i 个机关
        for (int i = 0; i <= q; i++) {
            if (f[i][s] == -1) continue;
            // 枚举下一步开启机关 j
            for (int j = 0; j < q; j++) {
                // 相同机关, 继续
                if (i == j) continue;
                // 机关被开启了, 继续
                if (((s >> j) & 1) != 0) continue;
                // 第i个机关到第j个机关走不通, 继续
                if (ttDist[i][j] == INF) continue;
                int cost = ttDist[i][j];
                // next status
                int ns = s | (1 << j);
                if (f[j][ns] == -1 || f[j][ns] > f[i][s] + cost) {
                    f[j][ns] = f[i][s] + cost;
                }
            }
        }
    }

 5. 获取结果

    int res = INF;
    // 枚举任意一个机关, 包括 startPoint
    for (int i = 0; i <= q; i++) {
        // 该状态没有被更新，继续
        if (f[i][lim - 1] == -1) {
            continue;
        }
        // 机关到终点走不通，继续
        if (tsDist[i][p] == -1) {
            continue;
        }
        // 结果 = 所有机关全部开启的最少步数 + 当前机关走到终点的最少步数
        int cur = f[i][lim - 1] + tsDist[i][p];
        res = Math.min(res, cur);
    }

 代码如下

class Solution {
    private int[][] dist;
    private Queue<Point> queue;
    private int[] dir = {-1, 0, 1, 0, -1};  // 压缩方向数组，二维变一维, {-1,0},{0,1},{1,0},{0,-1}
    private int n;
    private int m;
    private int[][] tsDist; // trigger to stone dist
    private int[][] ttDist;  // trigger to trigger dist
    private int[][] f;
    private int INF = 0x3f3f3f3f;

    public int minimalSteps(String[] maze) {
        this.n = maze.length;
        this.m = maze[0].length();
        dist = new int[150][150];
        tsDist = new int[20][45];
        ttDist = new int[20][20];
        f = new int[20][1 << 16];
        queue = new LinkedList<>();

        Point startPoint = null;
        Point endPoint = null;
        List<Point> stones = new ArrayList<>();
        List<Point> triggers = new ArrayList<>();

        // 为了方便, string maze -> matrix
        char[][] mat = new char[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                mat[i][j] = maze[i].charAt(j);
            }
        }
        // init maze
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (mat[i][j] == 'S') {
                    startPoint = new Point(i, j);
                    mat[i][j] = '.';
                    continue;
                }
                if (mat[i][j] == 'T') {
                    endPoint = new Point(i, j);
                    mat[i][j] = '.';
                    continue;
                }
                if (mat[i][j] == 'O') {
                    stones.add(new Point(i, j));
                    mat[i][j] = '.';
                    continue;
                }
                if (mat[i][j] == 'M') {
                    triggers.add(new Point(i, j));
                    mat[i][j] = '.';
                }
            }
        }

        // 起点(S) -> 石堆 -> 机关 -> 石堆 -> 机关 ... -> 石堆 -> 机关 -> 终点(T)
        // 更为统一的: 把起点认为是机关, 终点认为是石堆, 比较方便
        // 机关(S) -> 石堆 -> 机关 -> 石堆 -> 机关 ... -> 石堆 -> 机关 -> 石堆
        triggers.add(startPoint);
        stones.add(endPoint);

        int p = stones.size() - 1;
        int q = triggers.size() - 1;

        // 初始化 tsDist 数组: 计算任意一个机关(trigger) i 到任意一个石堆(stone) j 的距离
        for (int i = 0; i <= q; i++) {
            for (int j = 0; j <= p; j++) {
                tsDist[i][j] = bfs(triggers.get(i), stones.get(j), mat);
            }
        }

        // 初始化 ttDist 数组：当前位于第 i 个机关，下一步要开启第 j 个机关，最少要走多少步
        // 即第 i 个机关走向某个石堆 k，再从该石堆走向机关 j 的步数, floyd
        for (int i = 0; i <= q; i++) {
            for (int j = 0; j <= q; j++) {
                ttDist[i][j] = INF;
                // 枚举石堆, 不算终点
                for (int k = 0; k < p; k++) {
                    if (tsDist[i][k] == -1 || tsDist[j][k] == -1) continue;
                    int cost = tsDist[i][k] + tsDist[j][k];
                    ttDist[i][j] = Math.min(ttDist[i][j], cost);
                }
            }
        }

        // 初始化 dp 数组
        for (int[] a : f) {
            Arrays.fill(a, -1);
        }
        // 最后一个起点0表示未开启。
        f[q][0] = 0;

        // 枚举机关所有状态 staus
        int lim = 1 << q;
        for (int s = 0; s < lim; s++) {
            // 枚举位于第 i 个机关
            for (int i = 0; i <= q; i++) {
                if (f[i][s] == -1) continue;
                // 枚举下一步开启机关 j
                for (int j = 0; j < q; j++) {
                    // 相同机关, 继续
                    if (i == j) continue;
                    // 机关被开启了, 继续
                    if (((s >> j) & 1) != 0) continue;
                    // 第i个机关到第j个机关走不通, 继续
                    if (ttDist[i][j] == INF) continue;
                    int cost = ttDist[i][j];
                    int ns = s | (1 << j);
                    if (f[j][ns] == -1 || f[j][ns] > f[i][s] + cost) {
                        f[j][ns] = f[i][s] + cost;
                    }
                }
            }
        }

        int res = INF;
        for (int i = 0; i <= q; i++) {
            if (f[i][lim - 1] == -1) {
                continue;
            }
            if (tsDist[i][p] == -1) {
                continue;
            }
            int cur = f[i][lim - 1] + tsDist[i][p];
            res = Math.min(res, cur);
        }
        return res == INF ? -1 : res;
    }


    /**
     * BFS: 从给定起点到给定终点最少需要走多少步
     *
     * @param from 起点
     * @param to   终点
     * @return 步数
     */
    private int bfs(Point from, Point to, char[][] maze) {
        // 特判: 如果是墙壁, 返回-1
        if (maze[from.x][from.y] == '#') {
            return -1;
        }
        // 初始化 dist 数组
        for (int[] a : dist) {
            Arrays.fill(a, -1);
        }
        queue.offer(from);
        dist[from.x][from.y] = 0;

        while (!queue.isEmpty()) {
            Point cur = queue.poll();
            int x = cur.x;
            int y = cur.y;
            for (int i = 0; i < 4; i++) {
                int nx = x + dir[i];
                int ny = y + dir[i + 1];
                if (nx < 0 || nx >= n || ny < 0 || ny >= m || maze[nx][ny] == '#') continue;
                if (dist[nx][ny] == -1) {
                    dist[nx][ny] = dist[x][y] + 1;
                    queue.offer(new Point(nx, ny));
                }
            }
        }
        return dist[to.x][to.y];
    }

}
class Point {
    int x, y;

    public Point() {
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

 

 

【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DFS/BFS】2024D-地图寻宝【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-03 1482
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【独家OD2023C卷真题】20天拿下华为OD笔试【DFS/BFS】2023C-地图寻宝【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
12-06 2628
小华按照地图去寻宝，地图上被划分成 $$行和列的方格，横纵坐标范围分别是[0, n-1和[0, m-1]$$。在横坐标和纵坐标的数位之和不大于 $$的方格中存在黄金（每个方格中仅存在一克黄金），但横坐标和纵坐标数位之和大于的方格存在危险不可进入。小华从入口(0,0$$ 进入，任何时候只能向左，右，上，下四个方向移动一格。请问小华最多能获得多少克黄金？
leetcode **LCP 13. 寻宝（待研究）（2020.7.29）
Sophia_fez的博客
07-29 472
【题目】**LCP 13. 寻宝 我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。 迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但是，宝藏被一些隐蔽的机关保护了起来。在地图上有若干个机关点（用 ‘M’ 表示），只有所有机关均被触发，才可以拿到宝藏。 要保持机关的触发，需要把一个重石放在上面。迷宫中有若干个石堆（用 ‘O’ 表示），每个石堆都有无限个足够触发机关的重石。但是由于石头太重，我们一次只能搬一个石头到
leetcode LCP 13. 寻宝
qq_33789406的博客
07-29 182
leetcode LCP 13. 寻宝 题目详情 题目链接 我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。 迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但是，宝藏被一些隐蔽的机关保护了起来。在地图上有若干个机关点（用 ‘M’ 表示），只有所有机关均被触发，才可以拿到宝藏。 要保持机关的触发，需要把一个重石放在上面。迷宫中有若干个石堆（用 ‘O’ 表示），每个石堆都有无限个足够触发机关的重石。但是由于石头太
Leetcode LCP 13. 寻宝(bfs+状压dp)
REWINE
04-26 510
首先发现有用的点只有S，T，M，O，把他们提出来重新编号 通过bfs寻找两两之间的最短路dis。0 <= M的数量 <= 16，0 <= O的数量 <= 40 所以搜索量并不大。 问题是从S开始经过所有M后到达T，如果不考虑O，这就是经典的旅行商问题。 对于每个M点，达到之前必须经过一个O点，M,O并不多，这也就是说Mi经过O到Mj的最短路可以通过枚举O求得，记adis[M...
LeetCode LCP 13. 寻宝（状压dp）
da_kao_la的博客
07-29 359
LCP 13. 寻宝 我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。 迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但是，宝藏被一些隐蔽的机关保护了起来。在地图上有若干个机关点（用 ‘M’ 表示），只有所有机关均被触发，才可以拿到宝藏。 要保持机关的触发，需要把一个重石放在上面。迷宫中有若干个石堆（用 ‘O’ 表示），每个石堆都有无限个足够触发机关的重石。但是由于石头太重，我们一次只能搬一个石头到指定地点。
Leetcode刷题笔记 LCP 13. 寻宝
cjl的博客
07-30 497
LCP 13. 寻宝 时间：2020年7月29日 知识点：状态压缩动态规划 题目链接：https://leetcode-cn.com/problems/xun-bao/ 题目 我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。 迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但是，宝藏被一些隐蔽的机关保护了起来。在地图上有若干个机关点（用 ‘M’ 表示），只有所有机关均被触发，才可以拿到宝藏。 要保持机关的触发，需
LeetCode-Go:Go 语言 LeetCode 代码仓库
04-08
ABOUT 这个仓库主要用来储存 LeetCode 的 Go 语言代码。 TODO LCP 13.寻宝 Problem 493.翻转对 Problem 632.最小区间 Problem 130.被围绕的区域
LeetCode 第33题：搜索旋转排序数组
最新发布
Gemini的博客
06-02 84
题目要求我们在一个已经旋转过的排序数组中搜索一个给定的目标值。如果数组中存在这个目标值，则返回它的索引，否则返回 -1。例如：4-1通过这个旋转嘉年华的寻宝游戏，我们掌握了如何在旋转排序数组中快速找到目标值。二分查找的方法帮助我们高效地解决了这个问题。记住，在处理这种问题时，关键是识别哪一部分是有序的，并利用这个信息来缩小搜索范围。无论是在算法的世界，还是在日常生活中，找到目标的最快方法就是善于利用已有的信息和资源。希望大家在解决问题的过程中，能感受到算法的乐趣。
leetcode刷题中遇到的宝藏资源
u011423145的博客
11-23 300
码农找工作系列，知乎上很不错的算法系列，可以按照问题导向识别算法和数据结构，与leetcode刷题思维正好相反，它总结了常见的问题模式： 1. 滑动窗口。 2. 双指针。 3. 快慢指针。 4. 区间合并。 5. 循环排序。 6. 原地反转链表。 7. 树上的BFS。 8. 树上的DFS。 9. 双堆。 10. 子集。 11. 变种二分。 12. 最大前K个元素。 13. ...
编程题：寻宝游戏
08-25
用VS2010做的寻宝游戏小程序，与大家分享一下！
算法寻宝问题——回溯法 c++
02-17
寻宝问题是算法中常见的问题，可利用回溯法来解决这个问题
LeeCode LCP.13 寻宝【python】
MiuRui的博客
12-24 672
这么高频的题，这么难是我万万没想到的，差点当场裂开，这里就写一写博主研究官方答案和一众博主的思路，然后研究了很久得到的思路以及代码，就差抄了！！！！淦。 有一说一，这道题快把我写哭了，一个转行的菜鸡太难了，呜呜呜。 建议大家还是耐下心来看看，思路和注释很详细，看完这个篇文章再搞不懂这个题，我直接裂开。 【题目】 我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。 迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但
leetcode刷题（225）——用队列实现栈
/*Chen*/的博客
04-29 396
Implement the following operations of a stack using queues. push(x) -- Push element x onto stack. pop() -- Removes the element on top of the stack. top() -- Get the top element. empty() -- Return...
LeetCode-198 & 213：House Robber (房屋抢劫)
大树先生的博客
04-20 2126
每个房间里都有不同数量的财物，给出能抢劫的最大财物数。不能同时对相邻的房间进行抢劫。
LeetCode题解(LCP13)：地图寻宝(Python)
长行
01-14 437
题目：原题链接（困难） 标签：图、广度优先搜索、动态规划、深度优先搜索、记忆化递归 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N×M2+2N)O(N×M^2+2^N)O(N×M2+2N) : 其中M为地图边长；N为机关数量 O(N2)O(N^2)O(N2) 7412ms (7.69%) Ans 2 (Python) Ans 3 (Python) 解法一： class Solution: def __init__(self):
寻宝路线
bluekrystal的博客
04-12 1966
思路：动态规划，一个点的情况由上面一个点和左边点的情况递推得来。w[i][j]表示点(i,j)宝贝的最大值 w[i][j]=max(w[i-1][j]+maze[i][j],w[i][j-1]+maze[i][j]); v[i][j]表示走到点(i,j)一共有v[i][j]种方法。#include &lt;iostream&gt; #include&lt;cstring&gt; using nam...
LeetCode LCP 13. 寻宝 | Python
"大梦三千秋的博客
07-29 879
使用压缩动态规划的思路，解决 LeetCode《LCP 13. 寻宝》问题
VSCode中安装并使用LeetCode-leetcode-js-tdd进行JavaScript测试驱动开发
资源摘要信息:"VSCode 安装 LeetCode 指南及 LeetCode-JS-TDD 使用" 本资源摘要旨在详细说明如何在 Visual Studio Code（VSCode）环境中安装并使用 LeetCode-JS-TDD，以及与 LeetCode 相关的编程实践。文中涉及的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值