java dfs 最短距离

原创

mob64ca12f4d1ad 2025-01-04 04:04:29 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12f4d1ad的原创作品，请联系作者获取转载授权，否则将追究法律责任

使用Java实现深度优先搜索（DFS）求最短距离

在开发中，图的遍历是一项常见的需求，尤其是在许多算法中，深度优先搜索（DFS）是一种重要的方法。在本文中，我将向你介绍如何使用Java实现DFS算法来找出最短距离。我们将分步骤来完成这个任务，即使你是刚入门的开发者，也可以轻松理解。

流程概述

在实现DFS之前，我们先来看看整个流程。下表展示了实现DFS求最短距离的步骤：

步骤	描述
1	创建图的邻接表表示
2	实现DFS算法
3	计算每个节点的最短距离
4	输出结果

接下来，我们将逐步详细解释每一步需要做的事情。

步骤一：创建图的邻接表表示

我们首先需要定义一个图的结构，这里我们用邻接表来表示图。邻接表适合稀疏图的存储。

import java.util.*;

class Graph {
    private Map<Integer, List<Integer>> adjacencyList;

    public Graph() {
        adjacencyList = new HashMap<>();
    }

    // 添加边
    public void addEdge(int source, int destination) {
        adjacencyList.putIfAbsent(source, new ArrayList<>());
        adjacencyList.putIfAbsent(destination, new ArrayList<>());
        adjacencyList.get(source).add(destination);
        adjacencyList.get(destination).add(source); // 因为是无向图
    }

    // 获取邻接表
    public Map<Integer, List<Integer>> getAdjacencyList() {
        return adjacencyList;
    }
}

解释

我们定义了一个Graph类，包含一个Map用于存储邻接表。
addEdge方法用于添加边，建立起图中节点的连接。

步骤二：实现DFS算法

在这个步骤中，我们将实现深度优先搜索。为了找到最短路径，我们会在DFS中的每一步记录当前的路径长度。

class DFS {
    private Set<Integer> visited;
    private int shortestDistance;

    public DFS() {
        visited = new HashSet<>();
        shortestDistance = Integer.MAX_VALUE;
    }

    public void dfs(Graph graph, int node, int distance) {
        // 如果已访问该节点，返回
        if (visited.contains(node)) return;

        // 记录访问
        visited.add(node);
        
        // 如果达到终点，更新最短距离
        if (node == targetNode) {
            shortestDistance = Math.min(shortestDistance, distance);
            return;
        }

        // 遍历邻接节点
        for (int neighbor : graph.getAdjacencyList().getOrDefault(node, new ArrayList<>())) {
            dfs(graph, neighbor, distance + 1); // 当前距离加一
        }

        // 结束访问，回溯
        visited.remove(node);
    }

    // 获取最短距离
    public int getShortestDistance() {
        return shortestDistance;
    }
}

解释

visited集合用于记录已访问的节点，防止重复访问。
shortestDistance记录当前的最短距离。
当我们深度遍历到终点节点时，更新最短距离。
DFS采用递归方式遍历每个邻接节点。

步骤三：计算每个节点的最短距离

为了找到从起点到终点的最短距离，我们需要初始化DFS并开始搜索。

public class Main {
    private static int targetNode = 4; // 假设终点是节点4

    public static void main(String[] args) {
        Graph graph = new Graph();
        graph.addEdge(1, 2);
        graph.addEdge(1, 3);
        graph.addEdge(2, 4);
        graph.addEdge(3, 4);
        graph.addEdge(2, 3);

        DFS dfs = new DFS();
        dfs.dfs(graph, 1, 0); // 从节点1开始搜索
        System.out.println("从节点1到节点" + targetNode + "的最短距离是：" + dfs.getShortestDistance());
    }
}

解释

我们创建了图并添加了一些边。
实例化DFS对象并从起点（节点1）开始搜索。
输出从起点到终点的最短距离。

流程示意图

我们可以使用mermaid语法来展示旅行图的过程：

journey
    title DFS Travel to Find Shortest Path
    section Start
      Start at Node 1: 5: Node 1
    section Traverse
      Visit Node 2: 4: Node 2
      Visit Node 4: 3: Node 4
    section Backtrack
      Back to Node 2: 2: Node 2
      Back to Node 1: 1: Node 1
    section Travel to Target
      Visit Node 3: 1: Node 3
      Visit Node 4: 0: Node 4

类图

现在，我们可以使用mermaid语法展示类图：

classDiagram
    class Graph {
        +Map<Integer, List<Integer>> adjacencyList
        +void addEdge(int source, int destination)
        +Map<Integer, List<Integer>> getAdjacencyList()
    }

    class DFS {
        +Set<Integer> visited
        +int shortestDistance
        +void dfs(Graph graph, int node, int distance)
        +int getShortestDistance()
    }