Question

Design an efficient algorithm to find the longest path in a directed acyclic graph. (Must handle general real-valued weights on the edges, including negative values.) Use C, Java, or Python.

Answer 1

//JAVA PROGRAM TO FIND THE LONGEST PATH IN A WEIGHTED DIRECTED ACYCLIC GRAPH HANDLING //REAL AND NEGATIVE WEIGHTS

import java.util.*;
class Edge   // Data structure to store graph edges
{
   int source, dest, weight;

   public Edge(int source, int dest, int weight) {
       this.source = source;
       this.dest = dest;
       this.weight = weight;
   }
};
class Graph
{
   // A List of Lists to represent an adjacency list
   List<List<Edge>> adjList = null;

   // Constructor
   Graph(List<Edge> edges, int N) {
       adjList = new ArrayList<>(N);

       for (int i = 0; i < N; i++) {
           adjList.add(i, new ArrayList<>());
       }

       // add edges to the undirected graph
       for (Edge edge: edges) {
           adjList.get(edge.source).add(edge);
       }
   }
}

class Main
{
   private static int DFS(Graph graph, int v, boolean[] discovered,
                           int[] departure, int time)
   {
       discovered[v] = true;

       for (Edge e : graph.adjList.get(v))
       {
           int u = e.dest;
           if (!discovered[u]) {
               time = DFS(graph, u, discovered, departure, time);
           }
       }
       departure[time] = v;
       time++;

       return time;
   }

   // The function performs topological sort on a given DAG and then finds out the longest distance of all vertices
   // from given source by running one pass of Bellman-Ford algorithm on edges of vertices in topological order

   public static void findLongestDistance(Graph graph, int source, int N)
   {
       int[] departure = new int[N];
       Arrays.fill(departure, -1);
       boolean[] discovered = new boolean[N];
       int time = 0;
       for (int i = 0; i < N; i++) {
           if (!discovered[i]) {
               time = DFS(graph, i, discovered, departure, time);
           }
       }

       int[] cost = new int[N];
       Arrays.fill(cost, Integer.MAX_VALUE);

       cost[source] = 0;

       // Process the vertices in topological order i.e. in order of their decreasing departure time in DFS
      
       for (int i = N - 1; i >= 0; i--)
       {
           int v = departure[i];
           for (Edge e : graph.adjList.get(v))
           {
               int u = e.dest;
               int w = e.weight * -1;   // negative the weight of edge
               if (cost[v] != Integer.MAX_VALUE && cost[v] + w < cost[u]) {
                   cost[u] = cost[v] + w;
               }
           }
       }

       for (int i = 0; i < N; i++)
       {
           System.out.printf("dist(%d, %d) = %2d\n", source, i, cost[i] * -1);
       }
   }

   public static void main(String[] args)
   {
       List<Edge> edges = Arrays.asList(
                               new Edge(0, 6, 8), new Edge(1, 2, -4), ///Edge(source,destination,weight)
                               new Edge(1, 4, 4), new Edge(1, 6, 4),
                               new Edge(3, 0, 2), new Edge(3, 4, 7),
                               new Edge(5, 1, -2), new Edge(7, 0, 2),
                               new Edge(7, 1, 6), new Edge(7, 3, 4),
                               new Edge(7, 5, 4)
                           );   

       final int N = 8; // number of vertices in the graph
       Graph graph = new Graph(edges, N);   // create a graph from given edges
       int source = 7;
       findLongestDistance(graph, source, N);
   }
}