Question

Problem 1: Dynamic Programming in DAG

Let G(V,E), |V| = n, be a directed acyclic graph presented in adjacency list representation, where the vertices are labelled with numbers in the set {1, . . . , n}, and where (i, j) is and edge inplies i < j. Suppose also that each vertex has a positive value vi, 1 ≤ i ≤ n. Define the value of a path as the sum of the values of the vertices belonging to the path. Give an O(|V | + |E|) algorithm that finds the path of maximum value in the graph.

Answer 1

Algorithm:

Approach:

We run a dfs to the graph and we calculate longest path from a node.

The longest path from a node is 1 plus maximum of longest path among all of it's children.

After calculating maximum distance for all the nodes of the directed acyclic graph we find the maximum among them and that will be the longest path in the graph.

Steps:

• V = vertices count
• val [ ] = array of values of vertices
• dist[ V+1 ] = { 0 }
• visited [ V+1 ] = {false}
• for u = 1 to V
  • if visited[u] == false
    • then call dfs(u, visited, value, dist) // this will fill the dist[] array
• longest_path = 0
• for u = 1 to V
  • longest_path = max(longest_path, dist[u])

// recursive dfs

• dfs(u, visited[ ], value[ ], dist[ ])
  • visited[u] = true
  • dist[u] = value[u]
  • for v in adj[u]
    • if visited[v] == false
      • dfs(v, visited, value, dist[ ]) // recursion
    • dist[u] = max(dist[u] , value[u] + dist[v] ) // calculating dist

Implementation in C++:

​​​​​​​

1 #include <bits/stdc++.h> using namespace std; void dfs(int node, vector int> adj[], int dp[], bool vis[]) { vis(node] = true; for (int i = 0; i < adj (node).size(); i++) { if (!vis[adj[node][i]]). dfs(adj (node][i], adj, dp, vis); dp [node] = max(dp[node], 1 + dp(adj (node][i]]); } } 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 int LongestPath(vector<int> adj[], int n) { int dp[n + i]; memset(dp, 0, sizeof dp); bool vis(n + 1); memset(vis, fatse, sizeof vis); for (int i = 1; i <= n; i++) { if (!vis[i]) dfs(i, adj, dp, vis); } int ans = 0; for (int i = 1; i <= n; i++) ans = max(ans, dp[i]); return ans; } int main() { int n = 5; vector<int> adj[n + ]; adj[1].push_back(2); adj[1].push_back(3); adj[3] .push_back(2); adj[2] .push_back(4); adj[3] .push back(4); cout << LongestPath(adj,n); return 0; }

Sample output:

3

Time complexity:

Since we are running a dfs in the graph and we have adjacency matrix given. So, the time complexity of this algorithm would be same as dfs which is .

If the answer helped please upvote, it means a lot and for any query please comment.