Dato un grafico aciclico diretto ponderato (DAG) e un vertice sorgente in esso, trova le distanze più lunghe dal vertice sorgente a tutti gli altri vertici nel grafico dato.
Abbiamo già discusso di come possiamo trovarlo Percorso più lungo nel grafico aciclico diretto (DAG) nel Set 1. In questo post discuteremo un'altra soluzione interessante per trovare il percorso più lungo del DAG che utilizza l'algoritmo per la ricerca Percorso più breve in un DAG .
L'idea è quella di negare i pesi del percorso e trovare il percorso più breve nel grafico . Un percorso più lungo tra due dati vertici s e t in un grafo pesato G è la stessa cosa di un percorso più breve in un grafo G' derivato da G cambiando ogni peso nella sua negazione. Quindi se i cammini più brevi si trovano in G' allora anche i cammini più lunghi si possono trovare in G.
Di seguito è riportato il processo passo passo per trovare i percorsi più lunghi:
Cambiamo il peso di ogni bordo di un dato grafico nella sua negazione e inizializziamo le distanze da tutti i vertici come infinite e la distanza dalla sorgente come 0, quindi troviamo un ordinamento topologico del grafico che rappresenta un ordinamento lineare del grafico. Quando consideriamo un vertice u in ordine topologico è garantito che abbiamo considerato ogni arco entrante su di esso. cioè abbiamo già trovato il percorso più breve per quel vertice e possiamo utilizzare tali informazioni per aggiornare il percorso più breve di tutti i suoi vertici adiacenti. Una volta ottenuto l'ordine topologico, elaboriamo uno per uno tutti i vertici in ordine topologico. Per ogni vertice elaborato aggiorniamo le distanze del vertice adiacente utilizzando la distanza più breve del vertice corrente dal vertice sorgente e il suo peso del bordo. cioè.
for every adjacent vertex v of every vertex u in topological order if (dist[v] > dist[u] + weight(u v)) dist[v] = dist[u] + weight(u v)
Una volta trovati tutti i percorsi più brevi dal vertice di origine, i percorsi più lunghi saranno solo la negazione dei percorsi più brevi.
Di seguito è riportata l’implementazione dell’approccio di cui sopra:
C++// A C++ program to find single source longest distances // in a DAG #include
# A Python3 program to find single source # longest distances in a DAG import sys def addEdge(u v w): global adj adj[u].append([v w]) # A recursive function used by longestPath. # See below link for details. # https:#www.geeksforgeeks.org/topological-sorting/ def longestPathUtil(v): global visited adjStack visited[v] = 1 # Recur for all the vertices adjacent # to this vertex for node in adj[v]: if (not visited[node[0]]): longestPathUtil(node[0]) # Push current vertex to stack which # stores topological sort Stack.append(v) # The function do Topological Sort and finds # longest distances from given source vertex def longestPath(s): # Initialize distances to all vertices # as infinite and global visited Stack adjV dist = [sys.maxsize for i in range(V)] # for (i = 0 i < V i++) # dist[i] = INT_MAX dist[s] = 0 for i in range(V): if (visited[i] == 0): longestPathUtil(i) # print(Stack) while (len(Stack) > 0): # Get the next vertex from topological order u = Stack[-1] del Stack[-1] if (dist[u] != sys.maxsize): # Update distances of all adjacent vertices # (edge from u -> v exists) for v in adj[u]: # Consider negative weight of edges and # find shortest path if (dist[v[0]] > dist[u] + v[1] * -1): dist[v[0]] = dist[u] + v[1] * -1 # Print the calculated longest distances for i in range(V): if (dist[i] == sys.maxsize): print('INT_MIN ' end = ' ') else: print(dist[i] * (-1) end = ' ') # Driver code if __name__ == '__main__': V = 6 visited = [0 for i in range(7)] Stack = [] adj = [[] for i in range(7)] addEdge(0 1 5) addEdge(0 2 3) addEdge(1 3 6) addEdge(1 2 2) addEdge(2 4 4) addEdge(2 5 2) addEdge(2 3 7) addEdge(3 5 1) addEdge(3 4 -1) addEdge(4 5 -2) s = 1 print('Following are longest distances from source vertex' s) longestPath(s) # This code is contributed by mohit kumar 29
// C# program to find single source longest distances // in a DAG using System; using System.Collections.Generic; // Graph is represented using adjacency list. Every node of // adjacency list contains vertex number of the vertex to // which edge connects. It also contains weight of the edge class AdjListNode { private int v; private int weight; public AdjListNode(int _v int _w) { v = _v; weight = _w; } public int getV() { return v; } public int getWeight() { return weight; } } // Graph class represents a directed graph using adjacency // list representation class Graph { private int V; // No. of vertices // Pointer to an array containing adjacency lists private List<AdjListNode>[] adj; public Graph(int v) // Constructor { V = v; adj = new List<AdjListNode>[ v ]; for (int i = 0; i < v; i++) adj[i] = new List<AdjListNode>(); } public void AddEdge(int u int v int weight) { AdjListNode node = new AdjListNode(v weight); adj[u].Add(node); // Add v to u's list } // A recursive function used by longestPath. See below // link for details. // https://www.geeksforgeeks.org/dsa/topological-sorting/ private void LongestPathUtil(int v bool[] visited Stack<int> stack) { // Mark the current node as visited visited[v] = true; // Recur for all the vertices adjacent to this // vertex foreach(AdjListNode node in adj[v]) { if (!visited[node.getV()]) LongestPathUtil(node.getV() visited stack); } // Push current vertex to stack which stores // topological sort stack.Push(v); } // The function do Topological Sort and finds longest // distances from given source vertex public void LongestPath(int s) { // Initialize distances to all vertices as infinite // and distance to source as 0 int[] dist = new int[V]; for (int i = 0; i < V; i++) dist[i] = Int32.MaxValue; dist[s] = 0; Stack<int> stack = new Stack<int>(); // Mark all the vertices as not visited bool[] visited = new bool[V]; for (int i = 0; i < V; i++) { if (visited[i] == false) LongestPathUtil(i visited stack); } // Process vertices in topological order while (stack.Count > 0) { // Get the next vertex from topological order int u = stack.Pop(); if (dist[u] != Int32.MaxValue) { // Update distances of all adjacent vertices // (edge from u -> v exists) foreach(AdjListNode v in adj[u]) { // consider negative weight of edges and // find shortest path if (dist[v.getV()] > dist[u] + v.getWeight() * -1) dist[v.getV()] = dist[u] + v.getWeight() * -1; } } } // Print the calculated longest distances for (int i = 0; i < V; i++) { if (dist[i] == Int32.MaxValue) Console.Write('INT_MIN '); else Console.Write('{0} ' dist[i] * -1); } Console.WriteLine(); } } public class GFG { // Driver code static void Main(string[] args) { Graph g = new Graph(6); g.AddEdge(0 1 5); g.AddEdge(0 2 3); g.AddEdge(1 3 6); g.AddEdge(1 2 2); g.AddEdge(2 4 4); g.AddEdge(2 5 2); g.AddEdge(2 3 7); g.AddEdge(3 5 1); g.AddEdge(3 4 -1); g.AddEdge(4 5 -2); int s = 1; Console.WriteLine( 'Following are longest distances from source vertex {0} ' s); g.LongestPath(s); } } // This code is contributed by cavi4762.
// A Java program to find single source longest distances // in a DAG import java.util.*; // Graph is represented using adjacency list. Every // node of adjacency list contains vertex number of // the vertex to which edge connects. It also // contains weight of the edge class AdjListNode { private int v; private int weight; AdjListNode(int _v int _w) { v = _v; weight = _w; } int getV() { return v; } int getWeight() { return weight; } } // Class to represent a graph using adjacency list // representation public class GFG { int V; // No. of vertices' // Pointer to an array containing adjacency lists ArrayList<AdjListNode>[] adj; @SuppressWarnings('unchecked') GFG(int V) // Constructor { this.V = V; adj = new ArrayList[V]; for (int i = 0; i < V; i++) { adj[i] = new ArrayList<>(); } } void addEdge(int u int v int weight) { AdjListNode node = new AdjListNode(v weight); adj[u].add(node); // Add v to u's list } // A recursive function used by longestPath. See // below link for details https:// // www.geeksforgeeks.org/topological-sorting/ void topologicalSortUtil(int v boolean visited[] Stack<Integer> stack) { // Mark the current node as visited visited[v] = true; // Recur for all the vertices adjacent to this // vertex for (int i = 0; i < adj[v].size(); i++) { AdjListNode node = adj[v].get(i); if (!visited[node.getV()]) topologicalSortUtil(node.getV() visited stack); } // Push current vertex to stack which stores // topological sort stack.push(v); } // The function to find Smallest distances from a // given vertex. It uses recursive // topologicalSortUtil() to get topological sorting. void longestPath(int s) { Stack<Integer> stack = new Stack<Integer>(); int dist[] = new int[V]; // Mark all the vertices as not visited boolean visited[] = new boolean[V]; for (int i = 0; i < V; i++) visited[i] = false; // Call the recursive helper function to store // Topological Sort starting from all vertices // one by one for (int i = 0; i < V; i++) if (visited[i] == false) topologicalSortUtil(i visited stack); // Initialize distances to all vertices as // infinite and distance to source as 0 for (int i = 0; i < V; i++) dist[i] = Integer.MAX_VALUE; dist[s] = 0; // Process vertices in topological order while (stack.isEmpty() == false) { // Get the next vertex from topological // order int u = stack.peek(); stack.pop(); // Update distances of all adjacent vertices if (dist[u] != Integer.MAX_VALUE) { for (AdjListNode v : adj[u]) { if (dist[v.getV()] > dist[u] + v.getWeight() * -1) dist[v.getV()] = dist[u] + v.getWeight() * -1; } } } // Print the calculated longest distances for (int i = 0; i < V; i++) if (dist[i] == Integer.MAX_VALUE) System.out.print('INF '); else System.out.print(dist[i] * -1 + ' '); } // Driver program to test above functions public static void main(String args[]) { // Create a graph given in the above diagram. // Here vertex numbers are 0 1 2 3 4 5 with // following mappings: // 0=r 1=s 2=t 3=x 4=y 5=z GFG g = new GFG(6); g.addEdge(0 1 5); g.addEdge(0 2 3); g.addEdge(1 3 6); g.addEdge(1 2 2); g.addEdge(2 4 4); g.addEdge(2 5 2); g.addEdge(2 3 7); g.addEdge(3 5 1); g.addEdge(3 4 -1); g.addEdge(4 5 -2); int s = 1; System.out.print( 'Following are longest distances from source vertex ' + s + ' n'); g.longestPath(s); } } // This code is contributed by Prithi_Dey
class AdjListNode { constructor(v weight) { this.v = v; this.weight = weight; } getV() { return this.v; } getWeight() { return this.weight; } } class GFG { constructor(V) { this.V = V; this.adj = new Array(V); for (let i = 0; i < V; i++) { this.adj[i] = new Array(); } } addEdge(u v weight) { let node = new AdjListNode(v weight); this.adj[u].push(node); } topologicalSortUtil(v visited stack) { visited[v] = true; for (let i = 0; i < this.adj[v].length; i++) { let node = this.adj[v][i]; if (!visited[node.getV()]) { this.topologicalSortUtil(node.getV() visited stack); } } stack.push(v); } longestPath(s) { let stack = new Array(); let dist = new Array(this.V); let visited = new Array(this.V); for (let i = 0; i < this.V; i++) { visited[i] = false; } for (let i = 0; i < this.V; i++) { if (!visited[i]) { this.topologicalSortUtil(i visited stack); } } for (let i = 0; i < this.V; i++) { dist[i] = Number.MAX_SAFE_INTEGER; } dist[s] = 0; let u = stack.pop(); while (stack.length > 0) { u = stack.pop(); if (dist[u] !== Number.MAX_SAFE_INTEGER) { for (let v of this.adj[u]) { if (dist[v.getV()] > dist[u] + v.getWeight() * -1) { dist[v.getV()] = dist[u] + v.getWeight() * -1; } } } } for (let i = 0; i < this.V; i++) { if (dist[i] === Number.MAX_SAFE_INTEGER) { console.log('INF'); } else { console.log(dist[i] * -1); } } } } let g = new GFG(6); g.addEdge(0 1 5); g.addEdge(0 2 3); g.addEdge(1 3 6); g.addEdge(1 2 2); g.addEdge(2 4 4); g.addEdge(2 5 2); g.addEdge(2 3 7); g.addEdge(3 5 1); g.addEdge(3 4 -1); g.addEdge(4 5 -2); console.log('Longest distances from the vertex 1 : '); g.longestPath(1); //this code is contributed by devendra
Produzione
Following are longest distances from source vertex 1 INT_MIN 0 2 9 8 10
Complessità temporale : La complessità temporale dell'ordinamento topologico è O(V+E). Dopo aver trovato l'ordine topologico l'algoritmo elabora tutti i vertici e per ogni vertice esegue un ciclo per tutti i vertici adiacenti. Poiché il totale dei vertici adiacenti in un grafico è O(E), il ciclo interno viene eseguito O(V + E) volte. Pertanto la complessità temporale complessiva di questo algoritmo è O(V + E).
Complessità spaziale:
La complessità spaziale dell'algoritmo di cui sopra è O(V). Stiamo memorizzando l'array di output e uno stack per l'ordinamento topologico.