Dijkstra's Algorithm for Competitive Programming

// Java Implementation

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    // Dijkstra's algorithm for dense graphs
    static List<Integer> dijkstra(int n, List<List<Pair>> adj, int src) {
        // Array to store minimum distances
        int[] dis = new int[n + 1];
        Arrays.fill(dis, Integer.MAX_VALUE);

        // Array to mark visited vertices
        boolean[] vis = new boolean[n + 1];

        // Set the distance to the source as 0
        dis[src] = 0;

        for (int i = 0; i < n; i++) {
            int v = -1;
            for (int j = 1; j <= n; j++) {
                if (!vis[j] && (v == -1 || dis[j] < dis[v]))
                    v = j;
            }

            if (dis[v] == Integer.MAX_VALUE)
                break;
            // Mark vertex v as visited
            vis[v] = true;

            for (Pair edge : adj.get(v)) {
                // Neighbor vertex
                int x = edge.vertex;
                // Edge weight
                int wt = edge.weight;

                // Update the distance if a shorter path is found
                if (dis[v] + wt < dis[x]) {
                    dis[x] = dis[v] + wt;
                }
            }
        }
        // Return the array of minimum distances
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            result.add(dis[i]);
        }
        return result;
    }

    public static void main(String[] args) {
        // Number of vertices
        int n = 6;
        // Adjacency list
        List<List<Pair>> adj = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }

        // Example: adding edges to the adjacency list

        // Edge from vertex 1 to 2 with weight 3
        adj.get(1).add(new Pair(2, 3));
        // Edge from vertex 1 to 3 with weight 5
        adj.get(1).add(new Pair(3, 5));
        // Edge from vertex 2 to 3 with weight 1
        adj.get(2).add(new Pair(3, 1));
        // Edge from vertex 3 to 4 with weight 2
        adj.get(3).add(new Pair(4, 2));
        // Edge from vertex 2 to 4 with weight 7
        adj.get(2).add(new Pair(4, 7));

        int src = 1; // Source vertex

        List<Integer> distances = dijkstra(n, adj, src);

        // Print the minimum distances from the source to all other vertices
        for (int i = 1; i <= n; i++) {
            System.out.println("Minimum distance from vertex " + 
                               src + " to " + i + " is " + distances.get(i));
        }
    }

    static class Pair {
        int vertex;
        int weight;

        Pair(int v, int w) {
            vertex = v;
            weight = w;
        }
    }
}


// This code is contributed by Sakshi

import java.util.*;

public class Dijkstra {

    // Pair class to store vertex and weight
    static class Pair implements Comparable<Pair> {
        int vertex, weight;

        // Constructor
        public Pair(int vertex, int weight) {
            this.vertex = vertex;
            this.weight = weight;
        }

        // Comparator for sorting in priority queue based on weight
        @Override
        public int compareTo(Pair other) {
            return Integer.compare(this.weight, other.weight);
        }
    }

    // Dijkstra's algorithm to find the shortest path from src to all other vertices
    public static ArrayList<Integer> dijkstra(int n, ArrayList<ArrayList<Pair>> adj, int src) {
        PriorityQueue<Pair> pq = new PriorityQueue<>();
        ArrayList<Integer> dis = new ArrayList<>(Collections.nCopies(n + 1, Integer.MAX_VALUE));
        
        // Initialize the source distance to 0 and add to priority queue
        dis.set(src, 0);
        pq.add(new Pair(src, 0));
        
        while (!pq.isEmpty()) {
            Pair curr = pq.poll(); // Get and remove the minimum weight pair
            int vertex = curr.vertex;
            int weight = curr.weight;
            
            // Skip processing if we have already found a better path
            if (dis.get(vertex) < weight) continue;
            
            // Explore all adjacent vertices
            for (Pair neighbour : adj.get(vertex)) {
                // Relaxation step: Check if a better path is found
                if (dis.get(neighbour.vertex) > weight + neighbour.weight) {
                    dis.set(neighbour.vertex, weight + neighbour.weight); // Update distance
                    pq.add(new Pair(neighbour.vertex, dis.get(neighbour.vertex))); // Add new pair to the queue
                }
            }
        }

        return dis; // Return the list of minimum distances
    }

    public static void main(String[] args) {
        int n = 6; // Number of vertices
        ArrayList<ArrayList<Pair>> adj = new ArrayList<>();
        
        // Initialize adjacency list
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }

        // Adding edges to the adjacency list
        adj.get(1).add(new Pair(2, 3));
        adj.get(1).add(new Pair(3, 5));
        adj.get(2).add(new Pair(3, 1));
        adj.get(3).add(new Pair(4, 2));
        adj.get(2).add(new Pair(4, 7));

        int src = 1; // Source vertex
        ArrayList<Integer> distances = dijkstra(n, adj, src); // Compute shortest paths

        // Print the distances
        for (int i = 1; i <= n; i++) {
            System.out.println("Minimum distance from vertex " + src + " to " + i + " is " + distances.get(i));
        }
    }
}

import java.util.*;

public class DijkstraAlgorithm {
    // Dijkstra's algorithm function to compute minimum
    // distances
    public static List<Integer>
    dijkstra(int n, int m, List<List<Pair> > adj, int src)
    {
        // Priority queue for min-heap
        PriorityQueue<Pair> p = new PriorityQueue<>(
            Comparator.comparingInt(pair -> pair.first));

        // Initialize distances
        List<Integer> distance = new ArrayList<>(
            Collections.nCopies(n + 1, Integer.MAX_VALUE));

        // Push the source vertex with a distance of 0
        p.add(new Pair(0, src));

        // Set the distance of the source vertex to 0
        distance.set(src, 0);

        while (!p.isEmpty()) {
            int curr = p.peek().second;
            int l = p.peek().first;
            p.poll();

            // Skip if this vertex has already been
            // processed with a shorter distance
            if (!distance.get(curr).equals(l)) {
                continue;
            }

            // Explore neighbors and update distances
            for (Pair x : adj.get(curr)) {
                // Neighbor vertex
                int d = x.first;

                // Edge weight
                int len = x.second;

                // Update the distance if a shorter path is
                // found
                if (distance.get(d)
                    > len + distance.get(curr)) {
                    distance.set(d,
                                 len + distance.get(curr));

                    // Push the updated distance and vertex
                    p.add(new Pair(distance.get(d), d));
                }
            }
        }

        return distance;
    }

    // Function to solve the problem
    public static void solve(int n, int m,
                             List<List<Integer> > edges)
    {
        // Adjacency list for edges
        List<List<Pair> > adj = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }

        // Build the adjacency list for edges
        for (int i = 0; i < m; i++) {
            int x = edges.get(i).get(0);
            int y = edges.get(i).get(1);
            int z = edges.get(i).get(2);
            adj.get(x).add(new Pair(y, z));
            adj.get(y).add(new Pair(x, z));
        }

        // Compute minimum distances from vertex 1 and
        // vertex N
        List<Integer> dis1 = dijkstra(n, m, adj, 1);
        List<Integer> dis2 = dijkstra(n, m, adj, n);

        int ans = Integer.MAX_VALUE;

        // Iterate through all edges to find the minimum
        // cost of reducing an edge to 0
        for (int i = 0; i < m; i++) {
            int v = edges.get(i).get(0);
            int u = edges.get(i).get(1);

            // Calculate the cost of reducing edge (v, u) to
            // 0
            ans = Math.min(
                ans, Math.min(dis1.get(v) + dis2.get(u),
                              dis1.get(u) + dis2.get(v)));
        }

        // Output the minimum cost
        System.out.println(ans);
    }

    public static void main(String[] args)
    {
        int n = 4, m = 4;
        // Edges as (vertex1, vertex2, weight)
        List<List<Integer> > edges = Arrays.asList(
            Arrays.asList(1, 2, 3), Arrays.asList(2, 3, 1),
            Arrays.asList(1, 3, 7), Arrays.asList(3, 4, 2));

        // Call the solve function to find the answer
        solve(n, m, edges);
    }
}

// Pair class to store (vertex, weight) pairs
class Pair {
    int first, second;

    Pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
// This code is contributed by Aman.