# Shortest path with exactly k edges in a directed and weighted graph

Given a directed and two vertices ‘u’ and ‘v’ in it, find shortest path from ‘u’ to ‘v’ with exactly k edges on the path.

The graph is given as adjacency matrix representation where value of graph[i][j] indicates the weight of an edge from vertex i to vertex j and a value INF(infinite) indicates no edge from i to j.

For example, consider the following graph. Let source ‘u’ be vertex 0, destination ‘v’ be 3 and k be 2. There are two walks of length 2, the walks are {0, 2, 3} and {0, 1, 3}. The shortest among the two is {0, 2, 3} and weight of path is 3+6 = 9.

The idea is to browse through all paths of length k from u to v using the approach discussed in the previous post and return weight of the shortest path. A **simple solution** is to start from u, go to all adjacent vertices, and recur for adjacent vertices with k as k-1, source as adjacent vertex and destination as v. Following are C++ and Java implementations of this simple solution.

## C++

`// C++ program to find shortest path with exactly k edges` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Define number of vertices in the graph and infinite value` `#define V 4` `#define INF INT_MAX` `// A naive recursive function to count walks from u to v with k edges` `int` `shortestPath(` `int` `graph[][V], ` `int` `u, ` `int` `v, ` `int` `k)` `{` ` ` `// Base cases` ` ` `if` `(k == 0 && u == v) ` `return` `0;` ` ` `if` `(k == 1 && graph[u][v] != INF) ` `return` `graph[u][v];` ` ` `if` `(k <= 0) ` `return` `INF;` ` ` `// Initialize result` ` ` `int` `res = INF;` ` ` `// Go to all adjacents of u and recur` ` ` `for` `(` `int` `i = 0; i < V; i++)` ` ` `{` ` ` `if` `(graph[u][i] != INF && u != i && v != i)` ` ` `{` ` ` `int` `rec_res = shortestPath(graph, i, v, k-1);` ` ` `if` `(rec_res != INF)` ` ` `res = min(res, graph[u][i] + rec_res);` ` ` `}` ` ` `}` ` ` `return` `res;` `}` `// driver program to test above function` `int` `main()` `{` ` ` `/* Let us create the graph shown in above diagram*/` ` ` `int` `graph[V][V] = { {0, 10, 3, 2},` ` ` `{INF, 0, INF, 7},` ` ` `{INF, INF, 0, 6},` ` ` `{INF, INF, INF, 0}` ` ` `};` ` ` `int` `u = 0, v = 3, k = 2;` ` ` `cout << ` `"Weight of the shortest path is "` `<<` ` ` `shortestPath(graph, u, v, k);` ` ` `return` `0;` `}` |

## Java

`// Dynamic Programming based Java program to find shortest path` `// with exactly k edges` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;` `class` `ShortestPath` `{` ` ` `// Define number of vertices in the graph and infinite value` ` ` `static` `final` `int` `V = ` `4` `;` ` ` `static` `final` `int` `INF = Integer.MAX_VALUE;` ` ` `// A naive recursive function to count walks from u to v` ` ` `// with k edges` ` ` `int` `shortestPath(` `int` `graph[][], ` `int` `u, ` `int` `v, ` `int` `k)` ` ` `{` ` ` `// Base cases` ` ` `if` `(k == ` `0` `&& u == v) ` `return` `0` `;` ` ` `if` `(k == ` `1` `&& graph[u][v] != INF) ` `return` `graph[u][v];` ` ` `if` `(k <= ` `0` `) ` `return` `INF;` ` ` `// Initialize result` ` ` `int` `res = INF;` ` ` `// Go to all adjacents of u and recur` ` ` `for` `(` `int` `i = ` `0` `; i < V; i++)` ` ` `{` ` ` `if` `(graph[u][i] != INF && u != i && v != i)` ` ` `{` ` ` `int` `rec_res = shortestPath(graph, i, v, k-` `1` `);` ` ` `if` `(rec_res != INF)` ` ` `res = Math.min(res, graph[u][i] + rec_res);` ` ` `}` ` ` `}` ` ` `return` `res;` ` ` `}` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `/* Let us create the graph shown in above diagram*/` ` ` `int` `graph[][] = ` `new` `int` `[][]{ {` `0` `, ` `10` `, ` `3` `, ` `2` `},` ` ` `{INF, ` `0` `, INF, ` `7` `},` ` ` `{INF, INF, ` `0` `, ` `6` `},` ` ` `{INF, INF, INF, ` `0` `}` ` ` `};` ` ` `ShortestPath t = ` `new` `ShortestPath();` ` ` `int` `u = ` `0` `, v = ` `3` `, k = ` `2` `;` ` ` `System.out.println(` `"Weight of the shortest path is "` `+` ` ` `t.shortestPath(graph, u, v, k));` ` ` `}` `}` |

## Python3

`# Python3 program to find shortest path` `# with exactly k edges` `# Define number of vertices in the graph` `# and infinite value` `# A naive recursive function to count` `# walks from u to v with k edges` `def` `shortestPath(graph, u, v, k):` ` ` `V ` `=` `4` ` ` `INF ` `=` `999999999999` ` ` ` ` `# Base cases` ` ` `if` `k ` `=` `=` `0` `and` `u ` `=` `=` `v:` ` ` `return` `0` ` ` `if` `k ` `=` `=` `1` `and` `graph[u][v] !` `=` `INF:` ` ` `return` `graph[u][v]` ` ` `if` `k <` `=` `0` `:` ` ` `return` `INF` `# Initialize result` ` ` `res ` `=` `INF` `# Go to all adjacents of u and recur` ` ` `for` `i ` `in` `range` `(V):` ` ` `if` `graph[u][i] !` `=` `INF ` `and` `u !` `=` `i ` `and` `v !` `=` `i:` ` ` `rec_res ` `=` `shortestPath(graph, i, v, k ` `-` `1` `)` ` ` `if` `rec_res !` `=` `INF:` ` ` `res ` `=` `min` `(res, graph[u][i] ` `+` `rec_res)` ` ` `return` `res` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `INF ` `=` `999999999999` ` ` ` ` `# Let us create the graph shown` ` ` `# in above diagram` ` ` `graph ` `=` `[[` `0` `, ` `10` `, ` `3` `, ` `2` `],` ` ` `[INF, ` `0` `, INF, ` `7` `],` ` ` `[INF, INF, ` `0` `, ` `6` `],` ` ` `[INF, INF, INF, ` `0` `]]` ` ` `u ` `=` `0` ` ` `v ` `=` `3` ` ` `k ` `=` `2` ` ` `print` `(` `"Weight of the shortest path is"` `,` ` ` `shortestPath(graph, u, v, k))` `# This code is contributed by PranchalK` |

## C#

`// Dynamic Programming based C# program to` `// find shortest pathwith exactly k edges` `using` `System;` `class` `GFG` `{` ` ` `// Define number of vertices in the` `// graph and infinite value` `const` `int` `V = 4;` `const` `int` `INF = Int32.MaxValue;` `// A naive recursive function to count` `// walks from u to v with k edges` `int` `shortestPath(` `int` `[,] graph, ` `int` `u,` ` ` `int` `v, ` `int` `k)` `{` ` ` `// Base cases` ` ` `if` `(k == 0 && u == v) ` `return` `0;` ` ` `if` `(k == 1 && graph[u, v] != INF) ` `return` `graph[u, v];` ` ` `if` `(k <= 0) ` `return` `INF;` ` ` `// Initialize result` ` ` `int` `res = INF;` ` ` `// Go to all adjacents of u and recur` ` ` `for` `(` `int` `i = 0; i < V; i++)` ` ` `{` ` ` `if` `(graph[u, i] != INF && u != i && v != i)` ` ` `{` ` ` `int` `rec_res = shortestPath(graph, i, v, k - 1);` ` ` `if` `(rec_res != INF)` ` ` `res = Math.Min(res, graph[u, i] + rec_res);` ` ` `}` ` ` `}` ` ` `return` `res;` `}` `// Driver Code` `public` `static` `void` `Main ()` `{` ` ` `/* Let us create the graph` ` ` `shown in above diagram*/` ` ` `int` `[,] graph = ` `new` `int` `[,]{{0, 10, 3, 2},` ` ` `{INF, 0, INF, 7},` ` ` `{INF, INF, 0, 6},` ` ` `{INF, INF, INF, 0}};` ` ` `GFG t = ` `new` `GFG();` ` ` `int` `u = 0, v = 3, k = 2;` ` ` `Console.WriteLine(` `"Weight of the shortest path is "` `+` ` ` `t.shortestPath(graph, u, v, k));` `}` `}` `// This code is contributed by Akanksha Rai` |

## Javascript

`<script>` `// Dynamic Programming based Javascript` `// program to find shortest path` `// with exactly k edges` `// Define number of vertices in the graph and infinite value` `let V = 4;` `let INF = Number.MAX_VALUE;` `// A naive recursive function to count walks from u to v` `// with k edges` `function` `shortestPath(graph,u,v,k)` `{` ` ` `// Base cases` ` ` `if` `(k == 0 && u == v) ` `return` `0;` ` ` `if` `(k == 1 && graph[u][v] != INF) ` `return` `graph[u][v];` ` ` `if` `(k <= 0) ` `return` `INF;` ` ` ` ` `// Initialize result` ` ` `let res = INF;` ` ` ` ` `// Go to all adjacents of u and recur` ` ` `for` `(let i = 0; i < V; i++)` ` ` `{` ` ` `if` `(graph[u][i] != INF && u != i && v != i)` ` ` `{` ` ` `let rec_res = shortestPath(graph, i, v, k-1);` ` ` `if` `(rec_res != INF)` ` ` `res = Math.min(res, graph[u][i] + rec_res);` ` ` `}` ` ` `}` ` ` `return` `res;` `}` `let graph=[[0, 10, 3, 2],[INF, 0, INF, 7],` ` ` `[INF, INF, 0, 6],[INF, INF, INF, 0]];` `let u = 0, v = 3, k = 2;` `document.write(` `"Weight of the shortest path is "` `+` ` ` `shortestPath(graph, u, v, k));` `// This code is contributed by rag2127` `</script>` |

**Output:**

Weight of the shortest path is 9

The worst-case time complexity of the above function is O(V^{k}) where V is the number of vertices in the given graph. We can simply analyze the time complexity by drawing recursion tree. The worst occurs for a complete graph. In worst case, every internal node of recursion tree would have exactly V children.

We can optimize the above solution using **Dynamic Programming**. The idea is to build a 3D table where first dimension is source, second dimension is destination, third dimension is number of edges from source to destination, and the value is count of walks. Like other Dynamic Programming problems, we fill the 3D table in bottom-up manner.

## C++

`// Dynamic Programming based C++ program to find shortest path with` `// exactly k edges` `#include <iostream>` `#include <climits>` `using` `namespace` `std;` `// Define number of vertices in the graph and infinite value` `#define V 4` `#define INF INT_MAX` `// A Dynamic programming based function to find the shortest path from` `// u to v with exactly k edges.` `int` `shortestPath(` `int` `graph[][V], ` `int` `u, ` `int` `v, ` `int` `k)` `{` ` ` `// Table to be filled up using DP. The value sp[i][j][e] will store` ` ` `// weight of the shortest path from i to j with exactly k edges` ` ` `int` `sp[V][V][k+1];` ` ` `// Loop for number of edges from 0 to k` ` ` `for` `(` `int` `e = 0; e <= k; e++)` ` ` `{` ` ` `for` `(` `int` `i = 0; i < V; i++) ` `// for source` ` ` `{` ` ` `for` `(` `int` `j = 0; j < V; j++) ` `// for destination` ` ` `{` ` ` `// initialize value` ` ` `sp[i][j][e] = INF;` ` ` `// from base cases` ` ` `if` `(e == 0 && i == j)` ` ` `sp[i][j][e] = 0;` ` ` `if` `(e == 1 && graph[i][j] != INF)` ` ` `sp[i][j][e] = graph[i][j];` ` ` `//go to adjacent only when number of edges is more than 1` ` ` `if` `(e > 1)` ` ` `{` ` ` `for` `(` `int` `a = 0; a < V; a++)` ` ` `{` ` ` `// There should be an edge from i to a and a` ` ` `// should not be same as either i or j` ` ` `if` `(graph[i][a] != INF && i != a &&` ` ` `j!= a && sp[a][j][e-1] != INF)` ` ` `sp[i][j][e] = min(sp[i][j][e], graph[i][a] +` ` ` `sp[a][j][e-1]);` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `sp[u][v][k];` `}` `// driver program to test above function` `int` `main()` `{` ` ` `/* Let us create the graph shown in above diagram*/` ` ` `int` `graph[V][V] = { {0, 10, 3, 2},` ` ` `{INF, 0, INF, 7},` ` ` `{INF, INF, 0, 6},` ` ` `{INF, INF, INF, 0}` ` ` `};` ` ` `int` `u = 0, v = 3, k = 2;` ` ` `cout << shortestPath(graph, u, v, k);` ` ` `return` `0;` `}` |

## Java

`// Dynamic Programming based Java program to find shortest path with` `// exactly k edges` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;` `class` `ShortestPath` `{` ` ` `// Define number of vertices in the graph and infinite value` ` ` `static` `final` `int` `V = ` `4` `;` ` ` `static` `final` `int` `INF = Integer.MAX_VALUE;` ` ` `// A Dynamic programming based function to find the shortest path` ` ` `// from u to v with exactly k edges.` ` ` `int` `shortestPath(` `int` `graph[][], ` `int` `u, ` `int` `v, ` `int` `k)` ` ` `{` ` ` `// Table to be filled up using DP. The value sp[i][j][e] will` ` ` `// store weight of the shortest path from i to j with exactly` ` ` `// k edges` ` ` `int` `sp[][][] = ` `new` `int` `[V][V][k+` `1` `];` ` ` `// Loop for number of edges from 0 to k` ` ` `for` `(` `int` `e = ` `0` `; e <= k; e++)` ` ` `{` ` ` `for` `(` `int` `i = ` `0` `; i < V; i++) ` `// for source` ` ` `{` ` ` `for` `(` `int` `j = ` `0` `; j < V; j++) ` `// for destination` ` ` `{` ` ` `// initialize value` ` ` `sp[i][j][e] = INF;` ` ` `// from base cases` ` ` `if` `(e == ` `0` `&& i == j)` ` ` `sp[i][j][e] = ` `0` `;` ` ` `if` `(e == ` `1` `&& graph[i][j] != INF)` ` ` `sp[i][j][e] = graph[i][j];` ` ` `// go to adjacent only when number of edges is` ` ` `// more than 1` ` ` `if` `(e > ` `1` `)` ` ` `{` ` ` `for` `(` `int` `a = ` `0` `; a < V; a++)` ` ` `{` ` ` `// There should be an edge from i to a and` ` ` `// a should not be same as either i or j` ` ` `if` `(graph[i][a] != INF && i != a &&` ` ` `j!= a && sp[a][j][e-` `1` `] != INF)` ` ` `sp[i][j][e] = Math.min(sp[i][j][e],` ` ` `graph[i][a] + sp[a][j][e-` `1` `]);` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `sp[u][v][k];` ` ` `}` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `/* Let us create the graph shown in above diagram*/` ` ` `int` `graph[][] = ` `new` `int` `[][]{ {` `0` `, ` `10` `, ` `3` `, ` `2` `},` ` ` `{INF, ` `0` `, INF, ` `7` `},` ` ` `{INF, INF, ` `0` `, ` `6` `},` ` ` `{INF, INF, INF, ` `0` `}` ` ` `};` ` ` `ShortestPath t = ` `new` `ShortestPath();` ` ` `int` `u = ` `0` `, v = ` `3` `, k = ` `2` `;` ` ` `System.out.println(` `"Weight of the shortest path is "` `+` ` ` `t.shortestPath(graph, u, v, k));` ` ` `}` `}` `//This code is contributed by Aakash Hasija` |

## Python3

`# Dynamic Programming based Python3` `# program to find shortest path with` `# A Dynamic programming based function` `# to find the shortest path from u to v` `# with exactly k edges.` `def` `shortestPath(graph, u, v, k):` ` ` `global` `V, INF` ` ` ` ` `# Table to be filled up using DP. The` ` ` `# value sp[i][j][e] will store weight` ` ` `# of the shortest path from i to j` ` ` `# with exactly k edges` ` ` `sp ` `=` `[[` `None` `] ` `*` `V ` `for` `i ` `in` `range` `(V)]` ` ` `for` `i ` `in` `range` `(V):` ` ` `for` `j ` `in` `range` `(V):` ` ` `sp[i][j] ` `=` `[` `None` `] ` `*` `(k ` `+` `1` `)` ` ` `# Loop for number of edges from 0 to k` ` ` `for` `e ` `in` `range` `(k ` `+` `1` `):` ` ` `for` `i ` `in` `range` `(V): ` `# for source` ` ` `for` `j ` `in` `range` `(V): ` `# for destination` ` ` ` ` `# initialize value` ` ` `sp[i][j][e] ` `=` `INF` ` ` `# from base cases` ` ` `if` `(e ` `=` `=` `0` `and` `i ` `=` `=` `j):` ` ` `sp[i][j][e] ` `=` `0` ` ` `if` `(e ` `=` `=` `1` `and` `graph[i][j] !` `=` `INF):` ` ` `sp[i][j][e] ` `=` `graph[i][j]` ` ` `# go to adjacent only when number` ` ` `# of edges is more than 1` ` ` `if` `(e > ` `1` `):` ` ` `for` `a ` `in` `range` `(V):` ` ` ` ` `# There should be an edge from` ` ` `# i to a and a should not be` ` ` `# same as either i or j` ` ` `if` `(graph[i][a] !` `=` `INF ` `and` `i !` `=` `a ` `and` ` ` `j!` `=` `a ` `and` `sp[a][j][e ` `-` `1` `] !` `=` `INF):` ` ` `sp[i][j][e] ` `=` `min` `(sp[i][j][e], graph[i][a] ` `+` ` ` `sp[a][j][e ` `-` `1` `])` ` ` ` ` `return` `sp[u][v][k]` `# Driver Code` `# Define number of vertices in` `# the graph and infinite value` `V ` `=` `4` `INF ` `=` `999999999999` `# Let us create the graph shown` `# in above diagram` `graph ` `=` `[[` `0` `, ` `10` `, ` `3` `, ` `2` `],` ` ` `[INF, ` `0` `, INF, ` `7` `],` ` ` `[INF, INF, ` `0` `, ` `6` `],` ` ` `[INF, INF, INF, ` `0` `]]` `u ` `=` `0` `v ` `=` `3` `k ` `=` `2` `print` `(` `"Weight of the shortest path is"` `,` ` ` `shortestPath(graph, u, v, k))` `# This code is contributed by PranchalK` |

## C#

`// Dynamic Programming based C# program to find` `// shortest path with exactly k edges` `using` `System;` `class` `GFG` `{` ` ` `// Define number of vertices in the graph` `// and infinite value` `static` `readonly` `int` `V = 4;` `static` `readonly` `int` `INF = ` `int` `.MaxValue;` `// A Dynamic programming based function to` `// find the shortest path from u to v` `// with exactly k edges.` `int` `shortestPath(` `int` `[,]graph, ` `int` `u, ` `int` `v, ` `int` `k)` `{` ` ` `// Table to be filled up using DP. The value` ` ` `// sp[i][j][e] will store weight of the shortest` ` ` `// path from i to j with exactly k edges` ` ` `int` `[,,]sp = ` `new` `int` `[V, V, k + 1];` ` ` `// Loop for number of edges from 0 to k` ` ` `for` `(` `int` `e = 0; e <= k; e++)` ` ` `{` ` ` `for` `(` `int` `i = 0; i < V; i++) ` `// for source` ` ` `{` ` ` `for` `(` `int` `j = 0; j < V; j++) ` `// for destination` ` ` `{` ` ` `// initialize value` ` ` `sp[i, j, e] = INF;` ` ` `// from base cases` ` ` `if` `(e == 0 && i == j)` ` ` `sp[i, j, e] = 0;` ` ` `if` `(e == 1 && graph[i, j] != INF)` ` ` `sp[i, j, e] = graph[i, j];` ` ` `// go to adjacent only when number of` ` ` `// edges is more than 1` ` ` `if` `(e > 1)` ` ` `{` ` ` `for` `(` `int` `a = 0; a < V; a++)` ` ` `{` ` ` `// There should be an edge from i to a and` ` ` `// a should not be same as either i or j` ` ` `if` `(graph[i, a] != INF && i != a &&` ` ` `j!= a && sp[a, j, e - 1] != INF)` ` ` `sp[i, j, e] = Math.Min(sp[i, j, e],` ` ` `graph[i, a] + sp[a, j, e - 1]);` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `sp[u, v, k];` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `/* Let us create the graph shown in above diagram*/` ` ` `int` `[,]graph = ` `new` `int` `[,]{ {0, 10, 3, 2},` ` ` `{INF, 0, INF, 7},` ` ` `{INF, INF, 0, 6},` ` ` `{INF, INF, INF, 0} };` ` ` `GFG t = ` `new` `GFG();` ` ` `int` `u = 0, v = 3, k = 2;` ` ` `Console.WriteLine(` `"Weight of the shortest path is "` `+` ` ` `t.shortestPath(graph, u, v, k));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` `// Dynamic Programming based Javascript program to find shortest path with` `// exactly k edges` `// Define number of vertices in the graph and infinite value` `let V = 4;` `let INF = Number.MAX_VALUE;` `// A Dynamic programming based function to find the shortest path` ` ` `// from u to v with exactly k edges.` `function` `shortestPath(graph, u, v, k)` `{` ` ` `// Table to be filled up using DP. The value sp[i][j][e] will` ` ` `// store weight of the shortest path from i to j with exactly` ` ` `// k edges` ` ` `let sp = ` `new` `Array(V);` ` ` `for` `(let i = 0; i < V; i++)` ` ` `{` ` ` `sp[i] = ` `new` `Array(V);` ` ` `for` `(let j = 0; j < V; j++)` ` ` `{` ` ` `sp[i][j] = ` `new` `Array(k + 1);` ` ` `for` `(let l = 0; l < (k + 1); l++)` ` ` `{` ` ` `sp[i][j][l] = 0;` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Loop for number of edges from 0 to k` ` ` `for` `(let e = 0; e <= k; e++)` ` ` `{` ` ` `for` `(let i = 0; i < V; i++) ` `// for source` ` ` `{` ` ` `for` `(let j = 0; j < V; j++) ` `// for destination` ` ` `{` ` ` `// initialize value` ` ` `sp[i][j][e] = INF;` ` ` ` ` `// from base cases` ` ` `if` `(e == 0 && i == j)` ` ` `sp[i][j][e] = 0;` ` ` `if` `(e == 1 && graph[i][j] != INF)` ` ` `sp[i][j][e] = graph[i][j];` ` ` ` ` `// go to adjacent only when number of edges is` ` ` `// more than 1` ` ` `if` `(e > 1)` ` ` `{` ` ` `for` `(let a = 0; a < V; a++)` ` ` `{` ` ` `// There should be an edge from i to a and` ` ` `// a should not be same as either i or j` ` ` `if` `(graph[i][a] != INF && i != a &&` ` ` `j!= a && sp[a][j][e-1] != INF)` ` ` `sp[i][j][e] = Math.min(sp[i][j][e],` ` ` `graph[i][a] + sp[a][j][e-1]);` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `sp[u][v][k];` `}` `let graph = [[0, 10, 3, 2], [INF, 0, INF, 7], [INF, INF, 0, 6], [INF, INF, INF, 0]];` `let u = 0, v = 3, k = 2;` `document.write(` `"Weight of the shortest path is "` `+` ` ` `shortestPath(graph, u, v, k));` `// This code is contributed by avanitrachhadiya2155` `</script>` |

**Output:**

Weight of the shortest path is 9

Time complexity of the above DP-based solution is O(V^{3}K) which is much better than the naive solution.

This article is contributed by **Abhishek**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.