广度优先搜索、dijkstra算法与A*启发式搜索

本文探讨了如何使用广度优先搜索、Dijkstra算法和A*启发式搜索解决LeetCode问题675,通过实例展示如何计算从起点砍倒所有树的最短步数,包括三种方法的时间复杂度和空间复杂度分析。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

leetcode:675.为高尔夫比赛砍树
题目要求:

你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n 的矩阵表示, 在这个矩阵中:
0 表示障碍,无法触碰
1 表示地面,可以行走

比 1 大的数 表示有树的单元格,可以行走,数值表示树的高度
每一步,你都可以向上、下、左、右四个方向之一移动一个单位,如果你站的地方有一棵树,那么你可以决定是否要砍倒它。
你需要按照树的高度从低向高砍掉所有的树,每砍过一颗树,该单元格的值变为 1(即变为地面)。

你将从 (0, 0) 点开始工作,返回你砍完所有树需要走的最小步数。 如果你无法砍完所有的树,返回 -1 。
可以保证的是,没有两棵树的高度是相同的,并且你至少需要砍倒一棵树。

示例 1:
输入:forest = [[1,2,3],[0,0,4],[7,6,5]]
输出:6
解释:沿着上面的路径,你可以用 6 步,按从最矮到最高的顺序砍掉这些树。

示例 2:
输入:forest = [[1,2,3],[0,0,0],[7,6,5]]
输出:-1
解释:由于中间一行被障碍阻塞,无法访问最下面一行中的树。

示例 3:
输入:forest = [[2,3,4],[0,0,5],[8,7,6]]
输出:6
解释:可以按与示例 1 相同的路径来砍掉所有的树。
(0,0) 位置的树,可以直接砍去,不用算步数。
 
提示:
m == forest.length
n == forest[i].length
1 <= m, n <= 50
0 <= forest[i][j] <= 10^9

一、广度优先搜索

class Solution:
    def cutOffTree(self, forest: List[List[int]]) -> int:

        # 方法一:广度优先搜索
        # 时间复杂度:O(m * n * m * n)
        # 空间复杂度:O(m * n)
        m, n = len(forest), len(forest[0])

        def bfs(i, j, target):
            queue = [(i, j, 0)]
            visited = set((i, j))

            while queue:
                i, j, step = queue.pop(0)
                if forest[i][j] == target:
                    return i, j, step
                for new_i, new_j in [(i+1, j), (i-1, j), (i, j-1), (i, j+1)]:
                    if 0 <= new_i < m and 0 <= new_j < n and (new_i, new_j) not in visited and forest[new_i][new_j] >= 1:
                        queue.append((new_i, new_j, step + 1))
                        visited.add((new_i, new_j))
            return -1, -1, -1

        trees = sorted([forest[i][j] for i in range(m) for j in range(n) if forest[i][j] > 1])
        #print(trees)
        ans = 0
        i, j = 0, 0
        for tree in trees:
            new_i, new_j, step = bfs(i, j, tree)
            #print(tree, step)
            if step == -1:
                return -1
            ans += step
            i, j = new_i, new_j
        return ans

二、dijkstra算法

// 方法二:dijkstra算法
// 时间复杂度:O(m * n * log(m * n))
// 空间复杂度:O(m * n)
class Solution {
    int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int bfs(List<List<Integer>> forest, int i, int j, int[] target){
        int target_i = target[0];
        int target_j = target[1];
        //System.out.println(target_i);
        //System.out.println(target_j);

        if (i == target_i && j == target_j){
            return 0;
        }

        int m = forest.size();
        int n = forest.get(0).size();
        PriorityQueue<int[]> queue = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
        boolean[][] visited = new boolean[m][n];
        queue.offer(new int[]{0, i * n + j});
        visited[i][j] = true;

        while (!queue.isEmpty()){
            int[] arr = queue.poll();
            int distance = arr[0], loc = arr[1];
            //System.out.println("distance:" + distance);
            //System.out.println("loc:" + loc);
            for (int index = 0; index < 4; ++index){
                int new_i = loc / n + dirs[index][0];
                int new_j = loc % n + dirs[index][1];
                //System.out.println("new_i:" + new_i + "new_j:" + new_j);
                if (0 <= new_i && new_i < m && 0 <= new_j && new_j < n){
                    if (!visited[new_i][new_j] && forest.get(new_i).get(new_j) > 0){
                        if (new_i == target_i && new_j == target_j){
                            return distance + 1;
                        }
                        queue.offer(new int[]{distance + 1, new_i * n + new_j});
                        visited[new_i][new_j] = true;
                    }
                }
            }       
        }
        return -1;
    }

    public int cutOffTree(List<List<Integer>> forest) {        
        List<int[]> trees = new ArrayList<int[]>();
        int m = forest.size();
        int n = forest.get(0).size();

        for (int i = 0; i < m; ++i){
            for (int j = 0; j < n; ++j){
                if (forest.get(i).get(j) > 1){
                    trees.add(new int[]{i, j});
                }
            }
        }
        Collections.sort(trees, (a, b) -> forest.get(a[0]).get(a[1]) - forest.get(b[0]).get(b[1]));
        //System.out.println(trees);

        int i = 0;
        int j = 0;
        int ans = 0;
        for (int index = 0; index < trees.size(); ++index){
            //System.out.println("trees.get(index):" + trees.get(index));
            int step = bfs(forest, i, j, trees.get(index));
            //System.out.println("step:" + step);
            if (step == -1){
                return -1;
            }
            ans += step;
            i = trees.get(index)[0];
            j = trees.get(index)[1];
        }
        return ans;
    }
}

三、A*启发式搜索

// 方法三:A*启发式算法
class Solution {
    int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int bfs(List<List<Integer>> forest, int i, int j, int[] target){
        int target_i = target[0];
        int target_j = target[1];
        //System.out.println(target_i);
        //System.out.println(target_j);

        if (i == target_i && j == target_j){
            return 0;
        }

        int m = forest.size();
        int n = forest.get(0).size();
        PriorityQueue<int[]> queue = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
        boolean[][] visited = new boolean[m][n];
        queue.offer(new int[]{0, i * n + j});
        visited[i][j] = true;

        while (!queue.isEmpty()){
            int[] arr = queue.poll();
            int distance = arr[0], loc = arr[1];
            //System.out.println("distance:" + distance);
            //System.out.println("loc:" + loc);
            for (int index = 0; index < 4; ++index){
                int new_i = loc / n + dirs[index][0];
                int new_j = loc % n + dirs[index][1];
                //System.out.println("new_i:" + new_i + "new_j:" + new_j);
                if (0 <= new_i && new_i < m && 0 <= new_j && new_j < n){
                    if (!visited[new_i][new_j] && forest.get(new_i).get(new_j) > 0){
                        if (new_i == target_i && new_j == target_j){
                            return distance + 1;
                        }
                        queue.offer(new int[]{distance + 1, new_i * n + new_j});
                        visited[new_i][new_j] = true;
                    }
                }
            }       
        }
        return -1;
    }

    public int cutOffTree(List<List<Integer>> forest) {        
        List<int[]> trees = new ArrayList<int[]>();
        int m = forest.size();
        int n = forest.get(0).size();

        for (int i = 0; i < m; ++i){
            for (int j = 0; j < n; ++j){
                if (forest.get(i).get(j) > 1){
                    trees.add(new int[]{i, j});
                }
            }
        }
        Collections.sort(trees, (a, b) -> forest.get(a[0]).get(a[1]) - forest.get(b[0]).get(b[1]));
        //System.out.println(trees);

        int i = 0;
        int j = 0;
        int ans = 0;
        for (int index = 0; index < trees.size(); ++index){
            //System.out.println("trees.get(index):" + trees.get(index));
            int step = bfs(forest, i, j, trees.get(index));
            //System.out.println("step:" + step);
            if (step == -1){
                return -1;
            }
            ans += step;
            i = trees.get(index)[0];
            j = trees.get(index)[1];
        }
        return ans;
    }
}
<think>好的,我现在需要比较Dijkstra算法A*算法的异同点。首先,我得回忆一下这两个算法的基本概念和原理。根据用户提供的引用内容,Dijkstra算法是用于有权图的最短路径搜索,而A*算法是在Dijkstra基础上加入了启发式函数。接下来,我需要从多个角度分析它们的区别和联系。 首先,核心原理方面。Dijkstra算法广度优先搜索的扩展,通过不断选择当前最短路径的节点来扩展搜索范围。而A*算法则结合了Dijkstra和贪心算法的优点,使用启发式函数来估计到目标的距离,从而优先搜索更有希望的节点。这一点在引用[3]中提到,A*的启发函数使其具有对目标的引导性。 然后是数据结构部分。两者都使用优先队列,但Dijkstra的优先级是基于从起点到当前节点的实际距离,而A*则是实际距离加上启发式估计值。这样A*可能在队列管理上更高效,因为它能更快地导向目标节点。 启发式函数是A*独有的,这也是两者最大的区别之一。引用[2]和[3]都提到,启发式函数帮助A*算法更快接近目标,减少不必要的节点扩展,而Dijkstra没有这个机制,导致它在某些情况下效率较低。 性能比较方面,Dijkstra的时间复杂度在最坏情况下较高,因为它可能遍历所有节点。而A*启发式函数有效的情况下,可以显著减少搜索范围,但若启发函数设计不好,可能退化为Dijkstra甚至更差。引用[3]也指出加权A*可以启发式的影响力,平衡最优解和速度。 应用场景上,Dijkstra适用于需要精确最短路径且不要求高效率的场景,比如网络路由。A*则更适合实时性要求高的场景,如游戏AI或机器人路径规划,因为它能快速找到可行路径,尤其是在启发式函数准确时。 联系方面,两者都是基于贪心策略的最短路径算法,且A*可以视为Dijkstra的改进版。引用[2]提到当启发函数为0时,A*就等同于Dijkstra,这说明它们有直接的关联。 接下来需要生成相关问题,确保覆盖用户可能感兴趣的方面,比如性能分析、优化方法、应用场景等。同时要确保使用正确的中文达和格式,如数学公式用$...$,独立公式用$$...$$,并正确引用提供的参考资料。</think>### Dijkstra算法A*算法对比 #### 1. **核心原理** - **Dijkstra算法**:以广度优先搜索为基础,逐步扩展当前最短路径的节点,确保找到全局最短路径。其优先级基于从起点到当前节点的实际距离$g(n)$[^2]。 - **A*算法**:在Dijkstra基础上引入**启发式函数$h(n)$**(估计当前节点到目标的最小代价),优先级由$f(n)=g(n)+h(n)$决定。通过启发式引导搜索方向,减少无效探索[^3]。 #### 2. **数据结构** - 共同点:均使用**优先队列**管理待探索节点。 - 差异: - **Dijkstra**:队列优先级仅依赖$g(n)$。 - **A***:优先级依赖$f(n)=g(n)+h(n)$,需额外计算$h(n)$。 #### 3. **启发式函数的作用** - **A*算法**:若$h(n)$满足**可采纳性**(即$h(n) \leq$真实代价),则保证找到最短路径;若进一步满足**一致性**(三角不等式),则无需重复更新节点。 - **Dijkstra**:无启发式函数,相当于A*中$h(n)=0$的特例[^2]。 #### 4. **性能对比** | **指标** | **Dijkstra** | **A*** | |----------------|---------------------------------------|---------------------------------------| | **时间复杂度** | $O((V+E)\log V)$(V为节点数,E为边数) | 取决于$h(n)$质量,最优情况下$O(b^d)$(b分支因子,d目标深度) | | **空间复杂度** | $O(V)$(存储所有节点信息) | Dijkstra类似,但可能探索更少节点 | | **适用场景** | 需全局最短路径的无目标导向搜索 | 目标明确且$h(n)$有效的场景(如地图导航)| #### 5. **典型应用** - **Dijkstra**:网络路由协议(如OSPF)、电力网络分析[^1]。 - **A***:游戏AI路径规划、机器人导航、实时策略游戏寻路[^3]。 #### 6. **联系改进** - **共同基础**:均属于**贪心算法**,通过局部最优逼近全局最优。 - **改进方向**:A*通过加权启发式($f(n)=g(n)+w\cdot h(n)$)平衡最优性速度(Weighted A*)。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值