Question

Help. I need to write a small program that executes the following graph algorithms in any language:

1. All-Pairs Shortest Path (Floyd-Warshall). It must ask for the vertices and edges for the user to enter them. As an output, deploy the resulting matrix. This will be done only for directed graphs.

2. Kruskal or Prim algorithm whatever you want to do. It must ask for a graph and present it at the end. The minimum coating tree that results from applying the algorithm. It can be presented as if it were a list of Vertices with ordered pairs that solve the edges. Kruskal or Prim will work with non-directed graphs.

Answer 1

1)

CODE

import java.util.Scanner;

public class AllPairShortestPath

{

    private int distancematrix[][];

    private int numberofvertices;

    public static final int INFINITY = 999;

    public AllPairShortestPath(int numberofvertices)

    {

        distancematrix = new int[numberofvertices + 1][numberofvertices + 1];

        this.numberofvertices = numberofvertices;

    }

    public void allPairShortestPath(int adjacencymatrix[][])

    {

        for (int source = 1; source <= numberofvertices; source++)

        {

            for (int destination = 1; destination <= numberofvertices; destination++)

            {

                distancematrix[source][destination] = adjacencymatrix[source][destination];

            }

        }

        for (int intermediate = 1; intermediate <= numberofvertices; intermediate++)

        {

            for (int source = 1; source <= numberofvertices; source++)

            {

                for (int destination = 1; destination <= numberofvertices; destination++)

                {

                    if (distancematrix[source][intermediate] + distancematrix[intermediate][destination]

                                         < distancematrix[source][destination])

                        distancematrix[source][destination] = distancematrix[source][intermediate] 

                                         + distancematrix[intermediate][destination];

                }

            }

        }

        for (int source = 1; source <= numberofvertices; source++)

            System.out.print("\t" + source);

        System.out.println();

        for (int source = 1; source <= numberofvertices; source++)

        {

            System.out.print(source + "\t");

            for (int destination = 1; destination <= numberofvertices; destination++)

            {

                System.out.print(distancematrix[source][destination] + "\t");

            }

            System.out.println();

        }

    }

    public static void main(String... arg)

    {

        int adjacency_matrix[][];

        int numberofvertices;

        Scanner scan = new Scanner(System.in);

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

        numberofvertices = scan.nextInt();

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

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

        for (int source = 1; source <= numberofvertices; source++)

        {

            for (int destination = 1; destination <= numberofvertices; destination++)

            {

                adjacency_matrix[source][destination] = scan.nextInt();

                if (source == destination)

                {

                    adjacency_matrix[source][destination] = 0;

                    continue;

                }

                if (adjacency_matrix[source][destination] == 0)

                {

                    adjacency_matrix[source][destination] = INFINITY;

                }

            }

        }

        System.out.println("The All-Pairs Shortest Path is: ");

        AllPairShortestPath allPairShortestPath= new AllPairShortestPath(numberofvertices);

        allPairShortestPath.allPairShortestPath(adjacency_matrix);

        scan.close();

    }

}

OUTPUT

Enter the number of vertices
4
 
Enter the Weighted Matrix for the graph
0 0 3 0
2 0 0 0 
0 7 0 1
6 0 0 0
 
The All-Pairs Shortest Path is:
 
        1       2       3       4
1       0       10      3       4       
2       2       0       5       6       
3       7       7       0       1       
4       6       16      9       0

2)

Kruskal Code in Java

import java.util.Collections;

import java.util.Comparator;

import java.util.LinkedList;

import java.util.List;

import java.util.Scanner;

import java.util.Stack;

public class KruskalAlgorithm

{

private List<Edge> edges;

private int numberOfVertices;

public static final int MAX_VALUE = 999;

private int visited[];

private int spanning_tree[][];

public KruskalAlgorithm(int numberOfVertices)

{

this.numberOfVertices = numberOfVertices;

edges = new LinkedList<Edge>();

visited = new int[this.numberOfVertices + 1];

spanning_tree = new int[numberOfVertices + 1][numberOfVertices + 1];

}

public void kruskalAlgorithm(int adjacencyMatrix[][])

{

boolean finished = false;

for (int source = 1; source <= numberOfVertices; source++)

{

for (int destination = 1; destination <= numberOfVertices; destination++)

{

if (adjacencyMatrix[source][destination] != MAX_VALUE && source != destination)

{

Edge edge = new Edge();

edge.sourcevertex = source;

edge.destinationvertex = destination;

edge.weight = adjacencyMatrix[source][destination];

adjacencyMatrix[destination][source] = MAX_VALUE;

edges.add(edge);

}

}

}

Collections.sort(edges, new EdgeComparator());

CheckCycle checkCycle = new CheckCycle();

for (Edge edge : edges)

{

spanning_tree[edge.sourcevertex][edge.destinationvertex] = edge.weight;

spanning_tree[edge.destinationvertex][edge.sourcevertex] = edge.weight;

if (checkCycle.checkCycle(spanning_tree, edge.sourcevertex))

{

spanning_tree[edge.sourcevertex][edge.destinationvertex] = 0;

spanning_tree[edge.destinationvertex][edge.sourcevertex] = 0;

edge.weight = -1;

continue;

}

visited[edge.sourcevertex] = 1;

visited[edge.destinationvertex] = 1;

for (int i = 0; i < visited.length; i++)

{

if (visited[i] == 0)

{

finished = false;

break;

} else

{

finished = true;

}

}

if (finished)

break;

}

System.out.println("The spanning tree is ");

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

System.out.print("\t" + i);

System.out.println();

for (int source = 1; source <= numberOfVertices; source++)

{

System.out.print(source + "\t");

for (int destination = 1; destination <= numberOfVertices; destination++)

{

System.out.print(spanning_tree[source][destination] + "\t");

}

System.out.println();

}

}

public static void main(String... arg)

{

int adjacency_matrix[][];

int number_of_vertices;

Scanner scan = new Scanner(System.in);

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] = MAX_VALUE;

}

}

}

KruskalAlgorithm kruskalAlgorithm = new KruskalAlgorithm(number_of_vertices);

kruskalAlgorithm.kruskalAlgorithm(adjacency_matrix);

scan.close();

}

}

class Edge

{

int sourcevertex;

int destinationvertex;

int weight;

}

class EdgeComparator implements Comparator<Edge>

{

@Override

public int compare(Edge edge1, Edge edge2)

{

if (edge1.weight < edge2.weight)

return -1;

if (edge1.weight > edge2.weight)

return 1;

return 0;

}

}

class CheckCycle

{

private Stack<Integer> stack;

private int adjacencyMatrix[][];

public CheckCycle()

{

stack = new Stack<Integer>();

}

public boolean checkCycle(int adjacency_matrix[][], int source)

{

boolean cyclepresent = false;

int number_of_nodes = adjacency_matrix[source].length - 1;

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

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

{

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

{

adjacencyMatrix[sourcevertex][destinationvertex] = adjacency_matrix[sourcevertex[destinationvertex];

}

}

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

int element = source;

int i = source;

visited[source] = 1;

stack.push(source);

while (!stack.isEmpty())

{

element = stack.peek();

i = element;

while (i <= number_of_nodes)

{

if (adjacencyMatrix[element][i] >= 1 && visited[i] == 1)

{

if (stack.contains(i))

{

cyclepresent = true;

return cyclepresent;

}

}

if (adjacencyMatrix[element][i] >= 1 && visited[i] == 0)

{

stack.push(i);

visited[i] = 1;

adjacencyMatrix[element][i] = 0;// mark as labelled;

adjacencyMatrix[i][element] = 0;

element = i;

i = 1;

continue;

}

i++;

}

stack.pop();

}

return cyclepresent;

}

}

OUTPUT

Enter the number of vertices
6
Enter the Weighted Matrix for the graph
0 6 8 6 0 0
6 0 0 5 10 0
8 0 0 7 5 3
6 5 7 0 0 0
0 10 5 0 0 3
0 0 3 0 3 0
The spanning tree is 
        1       2       3       4       5       6
1       0       6       0       0       0       0       
2       6       0       0       5       0       0       
3       0       0       0       7       0       3       
4       0       5       7       0       0       0       
5       0       0       0       0       0       3       
6       0       0       3       0       3       0