编写java代码，有向图，节点为node 边为edge，并求该图形的两点之间最短路径及长度。如果不可达则写成-1。

### 回答1：

以下是一份使用Java语言实现求解有向图中两点之间最短路径及长度的示例代码，其中节点用Node类表示，边用Edge类表示。示例代码中使用了Dijkstra算法求解最短路径，可以根据具体需求进行修改。

import java.util.*;

class Node {
    public int id;
    public List<Edge> edges;

    public Node(int id) {
        this.id = id;
        this.edges = new ArrayList<>();
    }
}

class Edge {
    public Node from, to;
    public int weight;

    public Edge(Node from, Node to, int weight) {
        this.from = from;
        this.to = to;
        this.weight = weight;
    }
}

public class ShortestPath {
    public static int dijkstra(Node start, Node end) {
        Map<Node, Integer> distance = new HashMap<>();
        Set<Node> visited = new HashSet<>();
        PriorityQueue<Node> queue = new PriorityQueue<>(Comparator.comparingInt(distance::getOrDefault));
        distance.put(start, 0);
        queue.offer(start);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            if (visited.contains(node)) {
                continue;
            }
            visited.add(node);
            if (node == end) {
                return distance.get(end);
            }
            for (Edge edge : node.edges) {
                Node next = edge.to;
                if (!distance.containsKey(next) || distance.get(node) + edge.weight < distance.get(next)) {
                    distance.put(next, distance.get(node) + edge.weight);
                    queue.offer(next);
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        // 构造有向图
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        node1.edges.add(new Edge(node1, node2, 2));
        node1.edges.add(new Edge(node1, node3, 4));
        node2.edges.add(new Edge(node2, node3, 1));
        node2.edges.add(new Edge(node2, node4, 7));
        node3.edges.add(new Edge(node3, node4, 3));

        // 求解最短路径
        int shortestPath = dijkstra(node1, node4);
        System.out.println("最短路径长度为：" + shortestPath);
    }
}

上述代码中，首先定义了Node类和Edge类，分别表示图中的节点和边。然后定义了一个dijkstra函数，使用Dijkstra算法求解从起点到终点的最短路径长度。最后在main函数中构造了一个有向图，并使用dijkstra函数求解最短路径长度。如果起点到终点不可达，则返回-1。

### 回答2：
在Java中，我们可以使用图的邻接矩阵表示有向图，并使用Dijkstra算法来求最短路径。下面是一个示例代码：

import java.util.Arrays;

public class ShortestPath {

    private static final int INF = Integer.MAX_VALUE; // 表示不可达的距离

    public static int[] findShortestPath(int[][] graph, int start, int end) {
        int n = graph.length; // 节点数
        boolean[] visited = new boolean[n]; // 标记节点是否已被访问
        int[] distance = new int[n]; // 从起始节点到每个节点的最短距离

        Arrays.fill(distance, INF);
        distance[start] = 0;

        for (int i = 0; i < n; i++) {
            int minDistance = INF;
            int minIndex = -1;

            // 找到未访问过的距离最小的节点
            for (int j = 0; j < n; j++) {
                if (!visited[j] && distance[j] < minDistance) {
                    minDistance = distance[j];
                    minIndex = j;
                }
            }

            if (minIndex == -1) {
                break; // 所有节点都已访问过，退出循环
            }

            visited[minIndex] = true;

            // 更新路径
            for (int j = 0; j < n; j++) {
                if (!visited[j] && graph[minIndex][j] != INF
                        && distance[minIndex] + graph[minIndex][j] < distance[j]) {
                    distance[j] = distance[minIndex] + graph[minIndex][j];
                }
            }
        }

        return distance;
    }

    public static void main(String[] args) {
        int[][] graph = {
                {0, 2, 5, INF, INF},
                {INF, 0, 2, 6, INF},
                {INF, INF, 0, 7, 1},
                {INF, INF, INF, 0, 3},
                {INF, INF, INF, INF, 0}
        };
        int start = 0;
        int end = 4;

        int[] distance = findShortestPath(graph, start, end);

        if (distance[end] == INF) {
            System.out.println("两点之间不可达，路径长度为-1");
        } else {
            System.out.println("两点之间的最短路径为：" + distance[end]);
        }
    }
}

上述代码使用邻接矩阵表示有向图，其中`INF`表示不可达的距离。`findShortestPath`方法使用Dijkstra算法求解最短路径。在`main`方法中，我们定义了一个示例图`graph`，并指定起始节点和结束节点。程序将输出最短路径的长度，如果两点不可达，则输出-1。

注意：该代码仅为简化示例，实际应用中可能需要进行参数有效性检查等处理。

### 回答3：
以下是一个简单的 Java 代码示例，用于求解有向图的最短路径和长度：

import java.util.*;

class Node {
    String name;
    List<Edge> edges;
    int distance;

    public Node(String name) {
        this.name = name;
        this.edges = new ArrayList<>();
        this.distance = Integer.MAX_VALUE;
    }

    public void addEdge(Edge edge) {
        edges.add(edge);
    }
}

class Edge {
    Node source;
    Node destination;
    int weight;

    public Edge(Node source, Node destination, int weight) {
        this.source = source;
        this.destination = destination;
        this.weight = weight;
    }
}

public class ShortestPath {
    public static void main(String[] args) {
        // 创建节点
        Node nodeA = new Node("A");
        Node nodeB = new Node("B");
        Node nodeC = new Node("C");
        Node nodeD = new Node("D");
        Node nodeE = new Node("E");

        // 创建边
        Edge edgeAB = new Edge(nodeA, nodeB, 2);
        Edge edgeBC = new Edge(nodeB, nodeC, 3);
        Edge edgeAD = new Edge(nodeA, nodeD, 4);
        Edge edgeDE = new Edge(nodeD, nodeE, 1);
        Edge edgeCE = new Edge(nodeC, nodeE, 5);

        // 添加边到对应节点的边列表
        nodeA.addEdge(edgeAB);
        nodeB.addEdge(edgeBC);
        nodeA.addEdge(edgeAD);
        nodeD.addEdge(edgeDE);
        nodeC.addEdge(edgeCE);

        // 设置起点和终点
        Node startNode = nodeA;
        Node endNode = nodeE;

        // 使用 Dijkstra 算法求解最短路径和长度
        findShortestPath(startNode);
        
        // 输出结果
        if (endNode.distance == Integer.MAX_VALUE) {
            System.out.println("不可达");
        } else {
            System.out.println("最短路径长度为：" + endNode.distance);

            List<Node> shortestPath = new ArrayList<>();
            Node currentNode = endNode;
            while (currentNode != null) {
                shortestPath.add(currentNode);
                currentNode = currentNode.prev;
            }

            Collections.reverse(shortestPath);

            System.out.print("最短路径为：");
            for (Node node : shortestPath) {
                System.out.print(node.name + " ");
            }
        }
    }
    
    public static void findShortestPath(Node startNode) {
        startNode.distance = 0;
        PriorityQueue<Node> queue = new PriorityQueue<>((a, b) -> a.distance - b.distance);
        queue.add(startNode);
        
        while (!queue.isEmpty()) {
            Node current = queue.poll();
            
            for (Edge edge : current.edges) {
                int newDistance = current.distance + edge.weight;
                if (newDistance < edge.destination.distance) {
                    edge.destination.distance = newDistance;
                    edge.destination.prev = current;
                    queue.add(edge.destination);
                }
            }
        }
    }
}

在上面的示例中，我们定义了两个类`Node`和`Edge`，分别用于表示图的节点和边。通过添加边到节点的边列表，我们可以创建有向图。然后，使用 Dijkstra 算法求解最短路径及其长度。最后，我们根据终点节点的`distance`属性来输出最短路径的长度，并且通过`prev`字段遍历节点，找到最短路径的各个节点。如果终点节点的`distance`属性仍然保持初始值`Integer.MAX_VALUE`，则表示不可达，输出-1。

请注意，上述代码仅仅是一个基本的示例，实际场景中可能需要考虑更多的因素，例如循环、错误处理等。