Minimum Cost using Dijkstra by Modifying Cost of an Edge

// java code addition 

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.*;
import java.util.*;

// Java code additin 

public class Main {
    
    static final int INF = 1000000000;
    // Function for Dijkstra Algorithm to
    // find single source shortest path
    static void dijkstra(int source, int n,
        ArrayList<ArrayList<ArrayList<Integer>>> adj,
        ArrayList<Integer> dist) {

        // Resize dist[] to N and assign
        // any large value to it
        Collections.fill(dist, INF);

        // Initialise distance of source
        // node as 0
        dist.set(source, 0);

        // Using min-heap priority_queue
        // for sorting wrt edges_cost
        PriorityQueue<ArrayList<Integer>> pq =
            new PriorityQueue<>(Comparator.comparing(o -> o.get(0)));

        // Push the current dist[source]
        // and source to pq
        pq.add(new ArrayList<>(Arrays.asList(dist.get(source), source)));

        // Until priority queue is empty
        while (!pq.isEmpty()) {
            // Store the cost of linked
            // node to edges
            int u = pq.peek().get(1);

            // Pop the top node
            pq.poll();

            // Iterate over edges
            for (ArrayList<Integer> edge : adj.get(u)) {
                // Find the starting and
                // ending vertex of edge
                int v = edge.get(0);
                int w = edge.get(1);

                // Update the distance of
                // node v to minimum of
                // dist[u] + w if it is
                // minimum
                if (dist.get(u) + w < dist.get(v)) {
                    dist.set(v, dist.get(u) + w);
                    pq.add(new ArrayList<>(Arrays.asList(dist.get(v), v)));
                }
            }
        }
    }

    // Function to find the minimum cost
    // between node 1 to node n
    static void minCostPath(
        ArrayList<ArrayList<Integer>> edges,
        int n, int M) {

        // To create Adjacency List
        ArrayList<ArrayList<ArrayList<Integer>>> adj =
            new ArrayList<>(n + 1);
        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<>());
        }

        // Iterate over edges
        for (int i = 0; i < M; i++) {
            // Get source, destination and
            // edges of edges[i]
            int x = edges.get(i).get(0);
            int y = edges.get(i).get(1);
            int z = edges.get(i).get(2);

            // Create Adjacency List
            adj.get(x).add(new ArrayList<>(Arrays.asList(y, z)));
            adj.get(y).add(new ArrayList<>(Arrays.asList(x, z)));
        }

        // To store the cost from node 1
        // and node N
        ArrayList<Integer> dist_from_source =
            new ArrayList<>(Collections.nCopies(n + 1, 0));
        ArrayList<Integer> dist_from_dest =
            new ArrayList<>(Collections.nCopies(n + 1, 0));

        // Find the cost of travel between
        // source(1) to any vertex
        dijkstra(1, n + 1, adj, dist_from_source);

        // Find the cost of travel between
        // destination(n) to any vertex
        dijkstra(n, n + 1, adj, dist_from_dest);

        // Initialise the minimum cost
        int min_cost = dist_from_source.get(n);

        // Traverse the edges
        for (ArrayList<Integer> it : edges) {
            // Get the edges
            int u = it.get(0);
            int v = it.get(1);
            int c = it.get(2);
            
            // Find the current cost from
            // node 1 to u and node u to v
            // and node v to N with only
            // current edge cost reduced
            // to half
            int cur_cost = dist_from_source.get(u) + c / 2 + dist_from_dest.get(v);

            // Update the min_cost
            min_cost = Math.min(min_cost, cur_cost);
        }
        
        System.out.println(min_cost);
    }

    public static void main(String[] args) {
        
            int N = 3;
            int M = 4;

            // Given Edges with cost
            ArrayList<ArrayList<Integer>> edges = new ArrayList<>();
        
            ArrayList<Integer> edge1 = new ArrayList<>();
            edge1.add(1);
            edge1.add(2);
            edge1.add(3);
            edges.add(edge1);

            ArrayList<Integer> edge2 = new ArrayList<>();
            edge2.add(2);
            edge2.add(3);
            edge2.add(1);
            edges.add(edge2);

            ArrayList<Integer> edge3 = new ArrayList<>();
            edge3.add(1);
            edge3.add(3);
            edge3.add(7);
            edges.add(edge3);

            ArrayList<Integer> edge4 = new ArrayList<>();
            edge4.add(1);
            edge4.add(3);
            edge4.add(7);
            edges.add(edge4);
        
            // Function Call
            minCostPath(edges, N, M);
    }
}

// The code is contributed by Nidhi goel.