Question

分配

后，我很难找出一个错误

int evaluationNode = getMinDistances();

settled.add(evaluationNode);

checkNeighbours(evaluationNode);

错误显示类型不匹配：connot从Node转换为int。如果有人能帮助我，我将不胜感激。以下是完整的代码。

import java.util.HashSet;

import java.util.InputMismatchException;

import java.util.PriorityQueue;

import java.util.Scanner;

import java.util.Set;
import java.util.Comparator;




public class DijkstraPriorityQueue

{

    private int distances[];

    private Set<Integer> settled;


    private PriorityQueue<Node> priorityQueue;

    private int number_of_nodes;

    private int adjacencyMatrix[][];


    public  DijkstraPriorityQueue(int number_of_nodes)
    {

        this.number_of_nodes = number_of_nodes;

        distances = new int[number_of_nodes + 1];

        settled = new HashSet<Integer>();

        priorityQueue = new PriorityQueue<Node>(number_of_nodes,new Node());

        adjacencyMatrix = new int[number_of_nodes + 1][number_of_nodes + 1];

    }

    public void dijkstra_algorithm(int adjacency_matrix[][], int source)
    {

        int evaluationNode;

        for (int i = 1; i <= number_of_nodes; i++)

            for (int j = 1; j <= number_of_nodes; j++)

                adjacencyMatrix[i][j] = adjacency_matrix[i][j];


        for (int i = 1; i <= number_of_nodes; i++)
        {
            distances[i] = Integer.MAX_VALUE;
        }

        priorityQueue.add(new Node(source, 0));

        distances[source] = 0;

        while (!priorityQueue.isEmpty())
        {

            evaluationNode = getMinDistances();

            settled.add(evaluationNode);

            evaluateNeighbours(evaluationNode);

        }

    } 

    private int getMinDistances()
    {

        int node = priorityQueue.remove();

        return node;

    }

    private void checkNeighbours(int evaluationNode)
    {

        int edgeDistance = -1;

        int newDistance = -1;


        for (int destinationNode = 1; destinationNode <= number_of_nodes; destinationNode++)
        {
            if (!settled.contains(destinationNode))
            {
                if (adjacencyMatrix[evaluationNode][destinationNode] != Integer.MAX_VALUE)
                {

                    edgeDistance = adjacencyMatrix[evaluationNode][destinationNode];

                    newDistance = distances[evaluationNode] + edgeDistance;

                    if (newDistance < distances[destinationNode])
                    {
                        distances[destinationNode] = newDistance;
                    }

                    priorityQueue.add(new Node(destinationNode,distances[destinationNode]));
                }   
            }
        }
    }

public static void main（String [] args）

    {

        int adjacency_matrix[][];

        int number_of_vertices;

        int source = 0;

        Scanner scan = new Scanner(System.in);

        try

        {

            System.out.println("Enter the number of vertices");

            number_of_vertices = scan.nextInt();

            adjacency_matrix = new int[number_of_vertices + 1][number_of_vertices + 1];



            System.out.println("Enter the Weighted Matrix for the graph");

            for (int i = 1; i <= number_of_vertices; i++)

            {

                for (int j = 1; j <= number_of_vertices; j++)

                {

                    adjacency_matrix[i][j] = scan.nextInt();

                    if (i == j)

                    {

                        adjacency_matrix[i][j] = 0;

                        continue;

                    }

                    if (adjacency_matrix[i][j] == 0)

                    {

                        adjacency_matrix[i][j] =  Integer.MAX_VALUE;

                    }

                }

            }



            System.out.println("Enter the source ");

            source = scan.nextInt();



            DijkstraPriorityQueue dijkstrasPriorityQueue = new DijkstraPriorityQueue(number_of_vertices);

            dijkstrasPriorityQueue.dijkstra_algorithm(adjacency_matrix, source);



            System.out.println("The Shorted Path to all nodes are ");

            for (int i = 1; i <= dijkstrasPriorityQueue.distances.length - 1; i++)

            {

                System.out.println(source + " to " + i + " is " + dijkstrasPriorityQueue.distances[i]);

            }

        } catch (InputMismatchException inputMismatch)

        {

            System.out.println("Wrong Input Format");

        }

        scan.close();

    } 

}

class Node implements Comparator<Node>

{

    public int node;

    public int cost;



    public Node()

    {

    }



    public Node(int node, int cost)

    {

        this.node = node;

        this.cost = cost;

    }



    @Override

    public int compare(Node node1, Node node2)

    {

        if (node1.cost < node2.cost)

            return -1;

        if (node1.cost > node2.cost)

            return 1;

        return 0;

    }

}

Answer 1

您正在调用的getMinDistances方法

int node = priorityQueue.remove();

但优先级队列包含Node个对象，而不包含int个值。

也许你想要像

这样的东西

private int getMinDistances()
{
    Node node = priorityQueue.remove();
    return node.getDistance();
}

但这是调试云（又称stackoverflow）无法回答的问题。

Answer 2

为了使用PriorityQueue，您必须实现扩展PriorityQueue的MinPQ，并且您还需要在节点之间使用比较器，以便在MinPQ中返回最小距离的节点。

查看here了解更多详情。

Java实现，优先级队列

2 个答案: