Find Maximum Shortest Distance in Each Component of a Graph

// Java code for the above approach:

import java.util.*;

public class Main {
    static boolean[] visited;
    // For storing the connected components
    static ArrayList <ArrayList <Integer> > components;
    
    // Below dfs function will be used to
    // get the connected components of a
    // graph and stores all the connected
    // nodes in the vector component
    static void dfs(int[][] graph, ArrayList<Integer> temp,int src, int N)
    {
        // Mark this vertex as visited
        visited[src] = true;

        // Put this node in component vector
        temp.add(src);

        // For all other vertices in graph
        for (int dest = 0; dest < N; dest++) {

            // If there is an edge between
            // src and dest i.e., the value
            // of graph[u][v]!=Integer.MAX_VALUE
            if (graph[src][dest] != Integer.MAX_VALUE) {

                // If we haven't visited dest
                // then recursively apply
                // dfs on dest
                if (!visited[dest])
                    dfs(graph, temp, dest, N);
            }
        }
    }
    // Below is the Floyd Warshall Algorithm
    // which is based on Dynamic Programming
    static void floydWarshall(int[][] graph, int N)
    {
        // For every vertex of graph find
        // the shortest distance with
        // other vertices
        for (int k = 0; k < N; k++) {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {

                    // Taking care of integer
                    // overflow
                    if (graph[i][k] != Integer.MAX_VALUE
                        && graph[k][j] != Integer.MAX_VALUE) {

                        // Update distance between
                        // vertex i and j if choosing
                        // k as an intermediate vertex
                        // make a shorter distance
                        if (graph[i][k] + graph[k][j]
                            < graph[i][j])
                            graph[i][j] = graph[i][k] + graph[k][j];
                    }
                }
            }
        }
    }
    // Function to find the maximum shortest
    // path distance in a component by checking
    // the shortest distances between all
    // possible pairs of nodes
    static int maxInThisComponent(int[][] graph, ArrayList <Integer> component)
    {
        int maxDistance = Integer.MIN_VALUE;
        int n = component.size();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                maxDistance
                    = Math.max(maxDistance,
                        graph[component.get(i)][component.get(j)]);
            }
        }

        // If the maxDistance is still Integer.MIN_VALUE
        // then return 0 because this component
        // has a single element
        return (maxDistance == Integer.MIN_VALUE
                    ? 0
                    : maxDistance);
    }

    // Below function uses above two method
    // to get the  maximum shortest distances
    // in each component of the graph the
    // function returns a vector, where each
    // element denotes maximum shortest path
    // distance for a component
    static ArrayList <Integer> maximumShortesDistances(int[][] graph, int N)
    {
        visited = new boolean[N];
        Arrays.fill(visited, false);
        // Find the connected components
        components =  new ArrayList <ArrayList<Integer> > ();

        // Now for each unvisited node run
        // the dfs to get the connected
        // component having this unvisited node
        for (int i = 0; i < N; i++) {
            if (!visited[i] ) {

                // For storing the nodes in a
                // particular component
                ArrayList<Integer> temp = new ArrayList<Integer> ();
                dfs(graph, temp, i, N);
                components.add(temp);
            }
        }

        // Now for all-pair find the shortest
        // path distances using Floyd Warshall
        floydWarshall(graph, N);

        // Now for each component find the
        // maximum shortest distance and
        // store it in result
        ArrayList <Integer> result = new ArrayList <Integer> ();
        int numOfComp = components.size();

        int maxDistance;
        for (int i = 0; i < numOfComp; i++) {
            maxDistance
                = maxInThisComponent(graph, components.get(i));
            result.add(maxDistance);
        }
        return result;
    }
    
    // Driver Code
    public static void main(String args[]) {
        int N = 8;
        final int inf = Integer.MAX_VALUE;

        // Adjacency Matrix for the first
        // graph in the examples
        int[][] graph = {
            { 0, inf, 9, inf, inf, inf, 3, inf },
            { inf, 0, inf, 10, 1, 8, inf, inf },
            { 9, inf, 0, inf, inf, inf, 11, inf },
            { inf, 10, inf, 0, 5, 13, inf, inf },
            { inf, 1, inf, 5, 0, 3, inf, inf },
            { 8, inf, inf, 13, 3, 0, inf, inf },
            { 3, inf, 11, inf, inf, inf, 0, inf },
            { inf, inf, inf, inf, inf, inf, inf, 0 },
        };

        // Find the maximum shortest distances
        ArrayList <Integer> result1
            = maximumShortesDistances(graph, N);

        // Printing the maximum shortest path
        // distances for each components
        for (int mx1 : result1)
            System.out.print(mx1 + " ");

    }
}

// This code has been contributed by Sachin Sahara (sachin801)