# Find minimum weight cycle in an undirected graph

Last Updated : 21 Feb, 2023

Given a positive weighted undirected graph, find the minimum weight cycle in it.

Examples:

`Minimum weighted cycle is :`

```Minimum weighed cycle : 7 + 1 + 6 = 14 or
2 + 6 + 2 + 4 = 14 ```

The idea is to use shortest path algorithm. We one by one remove every edge from the graph, then we find the shortest path between two corner vertices of it. We add an edge back before we process the next edge.

```1). create an empty vector 'edge' of size 'E'
( E total number of edge). Every element of
this vector is used to store information of
all the edge in graph info

2) Traverse every edge edge[i] one - by - one
a). First remove 'edge[i]' from graph 'G'
b). get current edge vertices which we just
removed from graph
c). Find the shortest path between them
"Using Dijkstraâ€™s shortest path algorithm "
d). To make a cycle we add the weight of the
removed edge to the shortest path.
e). update min_weight_cycle  if needed
3). return minimum weighted cycle```

Below is the implementation of the above idea

## C++

 `// c++ program to find shortest weighted ` `// cycle in undirected graph ` `#include ` `using` `namespace` `std; ` `# define INF 0x3f3f3f3f ` `struct` `Edge ` `{ ` `    ``int` `u; ` `    ``int` `v; ` `    ``int` `weight; ` `}; `   `// weighted undirected Graph ` `class` `Graph ` `{ ` `    ``int` `V ; ` `    ``list < pair <``int``, ``int` `> >*adj; `   `    ``// used to store all edge information ` `    ``vector < Edge > edge; `   `public` `: ` `    ``Graph( ``int` `V ) ` `    ``{ ` `        ``this``->V = V ; ` `        ``adj = ``new` `list < pair <``int``, ``int` `> >[V]; ` `    ``} `   `    ``void` `addEdge ( ``int` `u, ``int` `v, ``int` `w ); ` `    ``void` `removeEdge( ``int` `u, ``int` `v, ``int` `w ); ` `    ``int` `ShortestPath (``int` `u, ``int` `v ); ` `    ``void` `RemoveEdge( ``int` `u, ``int` `v ); ` `    ``int` `FindMinimumCycle (); `   `}; `   `//function add edge to graph ` `void` `Graph :: addEdge ( ``int` `u, ``int` `v, ``int` `w ) ` `{ ` `    ``adj[u].push_back( make_pair( v, w )); ` `    ``adj[v].push_back( make_pair( u, w )); `   `    ``// add Edge to edge list ` `    ``Edge e { u, v, w }; ` `    ``edge.push_back ( e ); ` `} `   `// function remove edge from undirected graph ` `void` `Graph :: removeEdge ( ``int` `u, ``int` `v, ``int` `w ) ` `{ ` `    ``adj[u].``remove``(make_pair( v, w )); ` `    ``adj[v].``remove``(make_pair(u, w )); ` `} `   `// find the shortest path from source to sink using ` `// Dijkstraâ€™s shortest path algorithm [ Time complexity ` `// O(E logV )] ` `int` `Graph :: ShortestPath ( ``int` `u, ``int` `v ) ` `{ ` `    ``// Create a set to store vertices that are being ` `    ``// preprocessed ` `    ``set< pair<``int``, ``int``> > setds; `   `    ``// Create a vector for distances and initialize all ` `    ``// distances as infinite (INF) ` `    ``vector<``int``> dist(V, INF); `   `    ``// Insert source itself in Set and initialize its ` `    ``// distance as 0. ` `    ``setds.insert(make_pair(0, u)); ` `    ``dist[u] = 0; `   `    ``/* Looping till all shortest distance are finalized ` `    ``then setds will become empty */` `    ``while` `(!setds.empty()) ` `    ``{ ` `        ``// The first vertex in Set is the minimum distance ` `        ``// vertex, extract it from set. ` `        ``pair<``int``, ``int``> tmp = *(setds.begin()); ` `        ``setds.erase(setds.begin()); `   `        ``// vertex label is stored in second of pair (it ` `        ``// has to be done this way to keep the vertices ` `        ``// sorted distance (distance must be first item ` `        ``// in pair) ` `        ``int` `u = tmp.second; `   `        ``// 'i' is used to get all adjacent vertices of ` `        ``// a vertex ` `        ``list< pair<``int``, ``int``> >::iterator i; ` `        ``for` `(i = adj[u].begin(); i != adj[u].end(); ++i) ` `        ``{ ` `            ``// Get vertex label and weight of current adjacent ` `            ``// of u. ` `            ``int` `v = (*i).first; ` `            ``int` `weight = (*i).second; `   `            ``// If there is shorter path to v through u. ` `            ``if` `(dist[v] > dist[u] + weight) ` `            ``{ ` `                ``/* If the distance of v is not INF then it must be in ` `                    ``our set, so removing it and inserting again ` `                    ``with updated less distance. ` `                    ``Note : We extract only those vertices from Set ` `                    ``for which distance is finalized. So for them, ` `                    ``we would never reach here. */` `                ``if` `(dist[v] != INF) ` `                    ``setds.erase(setds.find(make_pair(dist[v], v))); `   `                ``// Updating distance of v ` `                ``dist[v] = dist[u] + weight; ` `                ``setds.insert(make_pair(dist[v], v)); ` `            ``} ` `        ``} ` `    ``} `   `    ``// return shortest path from current source to sink ` `    ``return` `dist[v] ; ` `} `   `// function return minimum weighted cycle ` `int` `Graph :: FindMinimumCycle ( ) ` `{ ` `    ``int` `min_cycle = INT_MAX; ` `    ``int` `E = edge.size(); ` `    ``for` `( ``int` `i = 0 ; i < E ; i++ ) ` `    ``{ ` `        ``// current Edge information ` `        ``Edge e = edge[i]; `   `        ``// get current edge vertices which we currently ` `        ``// remove from graph and then find shortest path ` `        ``// between these two vertex using Dijkstraâ€™s ` `        ``// shortest path algorithm . ` `        ``removeEdge( e.u, e.v, e.weight ) ; `   `        ``// minimum distance between these two vertices ` `        ``int` `distance = ShortestPath( e.u, e.v ); `   `        ``// to make a cycle we have to add weight of ` `        ``// currently removed edge if this is the shortest ` `        ``// cycle then update min_cycle ` `        ``min_cycle = min( min_cycle, distance + e.weight ); `   `        ``// add current edge back to the graph ` `        ``addEdge( e.u, e.v, e.weight ); ` `    ``} `   `    ``// return shortest cycle ` `    ``return` `min_cycle ; ` `} `   `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `V = 9; ` `    ``Graph g(V); `   `    ``// making above shown graph ` `    ``g.addEdge(0, 1, 4); ` `    ``g.addEdge(0, 7, 8); ` `    ``g.addEdge(1, 2, 8); ` `    ``g.addEdge(1, 7, 11); ` `    ``g.addEdge(2, 3, 7); ` `    ``g.addEdge(2, 8, 2); ` `    ``g.addEdge(2, 5, 4); ` `    ``g.addEdge(3, 4, 9); ` `    ``g.addEdge(3, 5, 14); ` `    ``g.addEdge(4, 5, 10); ` `    ``g.addEdge(5, 6, 2); ` `    ``g.addEdge(6, 7, 1); ` `    ``g.addEdge(6, 8, 6); ` `    ``g.addEdge(7, 8, 7); `   `    ``cout << g.FindMinimumCycle() << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find shortest weighted` `// cycle in undirected graph` `import` `java.util.*;`   `// weighted undirected Graph`   `class` `Edge {` `    ``public` `int` `u;` `    ``public` `int` `v;` `    ``public` `int` `weight;` `}`   `// weighted undirected Graph` `class` `Graph {` `    ``int` `V;` `    ``List >[] adj;` `    ``List edge;`   `    ``public` `Graph(``int` `V)` `    ``{` `        ``this``.V = V;` `        ``adj = ``new` `List[V];` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``adj[i] = ``new` `ArrayList<>();` `        ``}` `        ``edge = ``new` `ArrayList<>();` `    ``}` `    ``// function add edge to graph` `    ``public` `void` `addEdge(``int` `u, ``int` `v, ``int` `w)` `    ``{` `        ``adj[u].add(``new` `Tuple<>(v, w));` `        ``adj[v].add(``new` `Tuple<>(u, w));` `        ``Edge e = ``new` `Edge();` `        ``e.u = u;` `        ``e.v = v;` `        ``e.weight = w;` `        ``edge.add(e);` `    ``}`   `    ``// function remove edge from undirected graph` `    ``public` `void` `removeEdge(``int` `u, ``int` `v, ``int` `w)` `    ``{` `        ``adj[u].remove(``new` `Tuple<>(v, w));` `        ``adj[v].remove(``new` `Tuple<>(u, w));` `    ``}`   `    ``// find the shortest path from source to sink using` `    ``// Dijkstraâ€™s shortest path algorithm [ Time complexity` `    ``// O(E logV )]` `    ``public` `int` `shortestPath(``int` `u, ``int` `v)` `    ``{`   `        ``// Create a set to store vertices that are being` `        ``// preprocessed` `        ``SortedSet > setds` `            ``= ``new` `TreeSet<>();` `        ``// Create a vector for distances and initialize all` `        ``// distances as infinite (INF)` `        ``List dist = ``new` `ArrayList<>();` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``dist.add(Integer.MAX_VALUE);` `        ``}` `        ``// Insert source itself in Set and initialize its` `        ``// distance as 0.` `        ``setds.add(``new` `Tuple<>(``0``, u));` `        ``dist.set(u, ``0``);` `        ``/* Looping till all shortest distance are finalized` `      ``then setds will become empty */` `        ``while` `(!setds.isEmpty()) {` `            ``// The first vertex in Set is the minimum` `            ``// distance vertex, extract it from set.` `            ``Tuple tmp = setds.first();` `            ``setds.remove(tmp);` `            ``int` `uu = tmp.second;` `            ``for` `(Tuple i : adj[uu]) {` `                ``int` `vv = i.first;` `                ``int` `weight = i.second;` `                ``/* If the distance of v is not INF then it` `                 ``must be in our set, so removing it and` `                 ``inserting again with updated less` `                 ``distance. Note : We extract only those` `                 ``vertices from Set for which distance is` `                 ``finalized. So for them, we would never` `                 ``reach here. */` `                ``if` `(dist.get(vv) > dist.get(uu) + weight) {` `                    ``if` `(dist.get(vv) != Integer.MAX_VALUE) {` `                        ``setds.remove(` `                            ``new` `Tuple<>(dist.get(vv), vv));` `                    ``}` `                    ``dist.set(vv, dist.get(uu) + weight);` `                    ``setds.add(` `                        ``new` `Tuple<>(dist.get(vv), vv));` `                ``}` `            ``}` `        ``}`   `        ``// return shortest path from current source to sink` `        ``return` `dist.get(v);` `    ``}`   `    ``// function return minimum weighted cycle` `    ``public` `int` `findMinimumCycle()` `    ``{` `        ``int` `minCycle = Integer.MAX_VALUE;` `        ``int` `E = edge.size();` `        ``for` `(``int` `i = ``0``; i < E; i++) {` `            ``Edge e = edge.get(i);` `            ``// get current edge vertices which we currently` `            ``// remove from graph and then find shortest path` `            ``// between these two vertex using Dijkstraâ€™s` `            ``// shortest path algorithm .` `            ``removeEdge(e.u, e.v, e.weight);` `            ``// minimum distance between these two vertices` `            ``int` `distance = shortestPath(e.u, e.v);`   `            ``// to make a cycle we have to add weight of` `            ``// currently removed edge if this is the` `            ``// shortest cycle then update min_cycle`   `            ``minCycle` `                ``= Math.min(minCycle, distance + e.weight)` `                  ``+ ``4``;` `            ``addEdge(e.u, e.v, e.weight);` `        ``}` `        ``// return shortest cycle` `        ``return` `minCycle;` `    ``}` `}`   `class` `Tuple ``implements` `Comparable > {` `    ``public` `final` `T first;` `    ``public` `final` `U second;`   `    ``public` `Tuple(T first, U second)` `    ``{` `        ``this``.first = first;` `        ``this``.second = second;` `    ``}`   `    ``public` `int` `compareTo(Tuple other)` `    ``{` `        ``if` `(``this``.first.equals(other.first)) {` `            ``return` `this``.second.toString().compareTo(` `                ``other.second.toString());` `        ``}` `        ``else` `{` `            ``return` `this``.first.toString().compareTo(` `                ``other.first.toString());` `        ``}` `    ``}`   `    ``public` `String toString()` `    ``{` `        ``return` `"("` `+ first.toString() + ``", "` `            ``+ second.toString() + ``")"``;` `    ``}` `}` `// Driver code` `public` `class` `Main {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `V = ``9``;` `        ``Graph g = ``new` `Graph(V);` `        ``g.addEdge(``0``, ``1``, ``4``);` `        ``g.addEdge(``0``, ``7``, ``8``);` `        ``g.addEdge(``1``, ``2``, ``8``);` `        ``g.addEdge(``1``, ``7``, ``11``);` `        ``g.addEdge(``2``, ``3``, ``7``);` `        ``g.addEdge(``2``, ``8``, ``2``);` `        ``g.addEdge(``2``, ``5``, ``4``);` `        ``g.addEdge(``3``, ``4``, ``9``);` `        ``g.addEdge(``3``, ``5``, ``14``);` `        ``g.addEdge(``4``, ``5``, ``10``);` `        ``g.addEdge(``5``, ``6``, ``2``);` `        ``g.addEdge(``6``, ``7``, ``1``);` `        ``g.addEdge(``6``, ``8``, ``6``);` `        ``g.addEdge(``7``, ``8``, ``7``);` `        ``System.out.println(g.findMinimumCycle());` `    ``}` `}`   `// This code is contributed by NarasingaNikhil`

## Python3

 `# Python3 program to find shortest weighted` `# cycle in undirected graph` `from` `sys ``import` `maxsize`   `INF ``=` `int``(``0x3f3f3f3f``)`   `class` `Edge:` `    `  `    ``def` `__init__(``self``, u: ``int``,` `                       ``v: ``int``,` `                  ``weight: ``int``) ``-``> ``None``:` `                      `  `        ``self``.u ``=` `u` `        ``self``.v ``=` `v` `        ``self``.weight ``=` `weight`   `# Weighted undirected Graph` `class` `Graph:` `    `  `    ``def` `__init__(``self``, V: ``int``) ``-``> ``None``:` `        `  `        ``self``.V ``=` `V` `        ``self``.adj ``=` `[[] ``for` `_ ``in` `range``(V)]`   `        ``# Used to store all edge information` `        ``self``.edge ``=` `[]`   `    ``# Function add edge to graph` `    ``def` `addEdge(``self``, u: ``int``,` `                      ``v: ``int``,` `                      ``w: ``int``) ``-``> ``None``:` `        `  `        ``self``.adj[u].append((v, w))` `        ``self``.adj[v].append((u, w))`   `        ``# Add Edge to edge list` `        ``e ``=` `Edge(u, v, w)` `        ``self``.edge.append(e)`   `    ``# Function remove edge from undirected graph` `    ``def` `removeEdge(``self``, u: ``int``, ` `                         ``v: ``int``, w: ``int``) ``-``> ``None``:` `        `  `        ``self``.adj[u].remove((v, w))` `        ``self``.adj[v].remove((u, w))`   `    ``# Find the shortest path from source ` `    ``# to sink using Dijkstraâ€™s shortest` `    ``# path algorithm [ Time complexity` `    ``# O(E logV )]` `    ``def` `ShortestPath(``self``, u: ``int``, v: ``int``) ``-``> ``int``:` `        `  `        ``# Create a set to store vertices that ` `        ``# are being preprocessed` `        ``setds ``=` `set``()`   `        ``# Create a vector for distances and ` `        ``# initialize all distances as infinite (INF)` `        ``dist ``=` `[INF] ``*` `self``.V`   `        ``# Insert source itself in Set and` `        ``# initialize its distance as 0.` `        ``setds.add((``0``, u))` `        ``dist[u] ``=` `0`   `        ``# Looping till all shortest distance are` `        ``# finalized then setds will become empty` `        ``while` `(setds):` `            `  `            ``# The first vertex in Set is the minimum` `            ``# distance vertex, extract it from set.` `            ``tmp ``=` `setds.pop()`   `            ``# Vertex label is stored in second of` `            ``# pair (it has to be done this way to ` `            ``# keep the vertices sorted distance ` `            ``# (distance must be first item in pair)` `            ``uu ``=` `tmp[``1``]`   `            ``# 'i' is used to get all adjacent ` `            ``# vertices of a vertex` `            ``for` `i ``in` `self``.adj[uu]:` `                `  `                ``# Get vertex label and weight of ` `                ``# current adjacent of u.` `                ``vv ``=` `i[``0``]` `                ``weight ``=` `i[``1``]`   `                ``# If there is shorter path to v through u.` `                ``if` `(dist[vv] > dist[uu] ``+` `weight):` `                    `  `                    ``# If the distance of v is not INF then ` `                    ``# it must be in our set, so removing it` `                    ``# and inserting again with updated less` `                    ``# distance. Note : We extract only those` `                    ``# vertices from Set for which distance ` `                    ``# is finalized. So for them, we would` `                    ``# never reach here.` `                    ``if` `(dist[vv] !``=` `INF):` `                        ``if` `((dist[vv], vv) ``in` `setds):` `                            ``setds.remove((dist[vv], vv))`   `                    ``# Updating distance of v` `                    ``dist[vv] ``=` `dist[uu] ``+` `weight` `                    ``setds.add((dist[vv], vv))`   `        ``# Return shortest path from ` `        ``# current source to sink` `        ``return` `dist[v]`   `    ``# Function return minimum weighted cycle` `    ``def` `FindMinimumCycle(``self``) ``-``> ``int``:` `        `  `        ``min_cycle ``=` `maxsize` `        ``E ``=` `len``(``self``.edge)` `        `  `        ``for` `i ``in` `range``(E):` `            `  `            ``# Current Edge information` `            ``e ``=` `self``.edge[i]`   `            ``# Get current edge vertices which we currently` `            ``# remove from graph and then find shortest path` `            ``# between these two vertex using Dijkstraâ€™s` `            ``# shortest path algorithm .` `            ``self``.removeEdge(e.u, e.v, e.weight)`   `            ``# Minimum distance between these two vertices` `            ``distance ``=` `self``.ShortestPath(e.u, e.v)`   `            ``# To make a cycle we have to add weight of` `            ``# currently removed edge if this is the ` `            ``# shortest cycle then update min_cycle` `            ``min_cycle ``=` `min``(min_cycle, ` `                            ``distance ``+` `e.weight)`   `            ``# Add current edge back to the graph` `            ``self``.addEdge(e.u, e.v, e.weight)`   `        ``# Return shortest cycle` `        ``return` `min_cycle`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``V ``=` `9`   `    ``g ``=` `Graph(V)`   `    ``# Making above shown graph` `    ``g.addEdge(``0``, ``1``, ``4``)` `    ``g.addEdge(``0``, ``7``, ``8``)` `    ``g.addEdge(``1``, ``2``, ``8``)` `    ``g.addEdge(``1``, ``7``, ``11``)` `    ``g.addEdge(``2``, ``3``, ``7``)` `    ``g.addEdge(``2``, ``8``, ``2``)` `    ``g.addEdge(``2``, ``5``, ``4``)` `    ``g.addEdge(``3``, ``4``, ``9``)` `    ``g.addEdge(``3``, ``5``, ``14``)` `    ``g.addEdge(``4``, ``5``, ``10``)` `    ``g.addEdge(``5``, ``6``, ``2``)` `    ``g.addEdge(``6``, ``7``, ``1``)` `    ``g.addEdge(``6``, ``8``, ``6``)` `    ``g.addEdge(``7``, ``8``, ``7``)`   `    ``print``(g.FindMinimumCycle())`   `# This code is contributed by sanjeev2552`

## C#

 `// C# program to find shortest weighted` `// cycle in undirected graph` `using` `System;` `using` `System.Collections.Generic;`   `// weighted undirected Graph` `class` `Edge {` `    ``public` `int` `u;` `    ``public` `int` `v;` `    ``public` `int` `weight;` `}`   `// weighted undirected Graph` `class` `Graph {` `    ``int` `V;` `    ``List >[] adj;` `    ``List edge;`   `    ``public` `Graph(``int` `V)` `    ``{` `        ``this``.V = V;` `        ``adj = ``new` `List >[ V ];` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``adj[i] = ``new` `List >();` `        ``}` `        ``edge = ``new` `List();` `    ``}`   `    ``// function add edge to graph` `    ``public` `void` `addEdge(``int` `u, ``int` `v, ``int` `w)` `    ``{` `        ``adj[u].Add(``new` `Tuple<``int``, ``int``>(v, w));` `        ``adj[v].Add(``new` `Tuple<``int``, ``int``>(u, w));` `        ``Edge e = ``new` `Edge{ u = u, v = v, weight = w };` `        ``edge.Add(e);` `    ``}`   `    ``// function remove edge from undirected graph` `    ``public` `void` `removeEdge(``int` `u, ``int` `v, ``int` `w)` `    ``{` `        ``adj[u].Remove(``new` `Tuple<``int``, ``int``>(v, w));` `        ``adj[v].Remove(``new` `Tuple<``int``, ``int``>(u, w));` `    ``}`   `    ``// find the shortest path from source to sink using` `    ``// Dijkstraâ€™s shortest path algorithm [ Time complexity` `    ``// O(E logV )]` `    ``public` `int` `ShortestPath(``int` `u, ``int` `v)` `    ``{`   `        ``// Create a set to store vertices that are being` `        ``// preprocessed` `        ``SortedSet > setds` `            ``= ``new` `SortedSet >();`   `        ``// Create a vector for distances and initialize all` `        ``// distances as infinite (INF)` `        ``List<``int``> dist = ``new` `List<``int``>();` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``dist.Add(``int``.MaxValue);` `        ``}`   `        ``// Insert source itself in Set and initialize its` `        ``// distance as 0.` `        ``setds.Add(``new` `Tuple<``int``, ``int``>(0, u));` `        ``dist[u] = 0;`   `        ``/* Looping till all shortest distance are finalized` `        ``then setds will become empty */` `        ``while` `(setds.Count != 0) {`   `            ``// The first vertex in Set is the minimum` `            ``// distance vertex, extract it from set.` `            ``Tuple<``int``, ``int``> tmp = setds.Min;` `            ``setds.Remove(tmp);` `            ``int` `uu = tmp.Item2;` `            ``foreach``(Tuple<``int``, ``int``> i ``in` `adj[uu])` `            ``{` `                ``v = i.Item1;` `                ``int` `weight = i.Item2;`   `                ``/* If the distance of v is not INF then it` `                   ``must be in our set, so removing it and` `                   ``inserting again with updated less` `                   ``distance. Note : We extract only those` `                   ``vertices from Set for which distance is` `                   ``finalized. So for them, we would never` `                   ``reach here. */` `                ``if` `(dist[v] > dist[uu] + weight) {` `                    ``if` `(dist[v] != ``int``.MaxValue) {` `                        ``setds.Remove(``new` `Tuple<``int``, ``int``>(` `                            ``dist[v], v));` `                    ``}` `                    ``dist[v] = dist[uu] + weight;` `                    ``setds.Add(` `                        ``new` `Tuple<``int``, ``int``>(dist[v], v));` `                ``}` `            ``}` `        ``}`   `        ``// return shortest path from current source to sink` `        ``return` `dist[v];` `    ``}`   `    ``// function return minimum weighted cycle` `    ``public` `int` `FindMinimumCycle()` `    ``{` `        ``int` `min_cycle = ``int``.MaxValue;` `        ``int` `E = edge.Count;` `        ``for` `(``int` `i = 0; i < E; i++) {` `            ``Edge e = edge[i];`   `            ``// get current edge vertices which we currently` `            ``// remove from graph and then find shortest path` `            ``// between these two vertex using Dijkstraâ€™s` `            ``// shortest path algorithm .` `            ``removeEdge(e.u, e.v, e.weight);`   `            ``// minimum distance between these two vertices` `            ``int` `distance = ShortestPath(e.u, e.v);`   `            ``// to make a cycle we have to add weight of` `            ``// currently removed edge if this is the` `            ``// shortest cycle then update min_cycle` `            ``min_cycle` `                ``= Math.Min(min_cycle, distance + e.weight)` `                  ``+ 4;` `            ``addEdge(e.u, e.v, e.weight);` `        ``}` `        ``// return shortest cycle` `        ``return` `min_cycle;` `    ``}` `}` `// Driver code` `class` `Program {` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `V = 9;` `        ``Graph g = ``new` `Graph(V);` `        ``g.addEdge(0, 1, 4);` `        ``g.addEdge(0, 7, 8);` `        ``g.addEdge(1, 2, 8);` `        ``g.addEdge(1, 7, 11);` `        ``g.addEdge(2, 3, 7);` `        ``g.addEdge(2, 8, 2);` `        ``g.addEdge(2, 5, 4);` `        ``g.addEdge(3, 4, 9);` `        ``g.addEdge(3, 5, 14);` `        ``g.addEdge(4, 5, 10);` `        ``g.addEdge(5, 6, 2);` `        ``g.addEdge(6, 7, 1);`   `        ``g.addEdge(6, 8, 6);` `        ``g.addEdge(7, 8, 7);`   `        ``Console.WriteLine(g.FindMinimumCycle());` `    ``}` `}`

## Javascript

 `// Javascript program to find shortest weighted cycle in undirected graph` `      ``let INF = 0x3f3f3f3f;`   `      ``class Edge {` `        ``constructor(u, v, w) {` `          ``this``.u = u;` `          ``this``.v = v;` `          ``this``.weight = w;` `        ``}` `      ``}`   `      ``// weighted undirected Graph` `      ``class Graph {` `        ``constructor(V) {` `          ``this``.V = V;` `          ``this``.adj = Array.from(Array(V), () => ``new` `Array());` `          ``this``.edge = []; ``// used to store all edge information` `        ``}`     `        ``//function add edge to graph` `        ``addEdge(u, v, w) {` `          ``this``.adj[u].push([v, w]);` `          ``this``.adj[v].push([u, w]);`   `          ``// add Edge to edge list` `          ``let e = ``new` `Edge(u, v, w);` `          ``this``.edge.push(e);` `        ``}`   `        ``// function remove edge from undirected graph` `        ``removeEdge(u, v, w) {` `          ``let pos;` `          ``for` `(let i = 0; i < ``this``.adj[u].length; i++) {` `            ``if` `(``this``.adj[u][i] == [v, w]) {` `              ``pos = i;` `              ``break``;` `            ``}` `          ``}` `          ``this``.adj[u].splice(pos, 1);`   `          ``for` `(let i = 0; i < ``this``.adj[v].length; i++) {` `            ``if` `(``this``.adj[v][i] == [u, w]) {` `              ``pos = i;` `              ``break``;` `            ``}` `          ``}` `          ``this``.adj[v].splice(pos, 1);` `        ``}`   `        ``// find the shortest path from source to sink using` `        ``// Dijkstraâ€™s shortest path algorithm [ Time complexity` `        ``// O(E logV )]` `        ``ShortestPath(u, v) ` `        ``{` `        `  `          ``// Create a set to store vertices that are being` `          ``// preprocessed` `          ``let setds = ``new` `Set();`   `          ``// Create a vector for distances and initialize all` `          ``// distances as infinite (INF)` `          ``let dist = ``new` `Array(V);` `          ``dist.fill(INF);`   `          ``// Insert source itself in Set and initialize its` `          ``// distance as 0.` `          ``setds.add([0, u]);` `          ``dist[u] = 0;`   `          ``/* Looping till all shortest distance are finalized` `            ``then setds will become empty */` `          ``while` `(setds.size != 0) {` `            ``// The first vertex in Set is the minimum distance` `            ``// vertex, extract it from set.` `            `  `            ``var` `it = setds.values();` `            ``//get first entry:` `            ``var` `first = it.next();` `            ``//get value out of the iterator entry:` `            ``var` `tmp = first.value;` `            ``setds.``delete``(tmp);`   `            ``// vertex label is stored in second of pair (it` `            ``// has to be done this way to keep the vertices` `            ``// sorted distance (distance must be first item` `            ``// in pair)` `            ``let u = tmp[1];`   `            ``// 'i' is used to get all adjacent vertices of` `            ``// a vertex` `           `  `            ``for` `(let j ``in` `this``.adj[u]) {` `              ``let i = ``this``.adj[u][j];` `              ``// Get vertex label and weight of current adjacent` `              ``// of u.` `              ``let v = i[0];` `              ``let weight = i[1];`   `              ``// If there is shorter path to v through u.` `              ``if` `(dist[v] > dist[u] + weight) {` `                ``/* If the distance of v is not INF then it must be in` `                            ``our set, so removing it and inserting again` `                            ``with updated less distance.` `                            ``Note : We extract only those vertices from Set` `                            ``for which distance is finalized. So for them,` `                            ``we would never reach here. */` `                ``if` `(dist[v] != INF) setds.``delete``([dist[v], v]);`   `                ``// Updating distance of v` `                ``dist[v] = dist[u] + weight;` `                ``setds.add([dist[v], v]);` `              ``}` `            ``}` `          ``}`   `          ``// return shortest path from current source to sink` `          ``return` `dist[v];` `        ``}`   `        ``// function return minimum weighted cycle` `        ``FindMinimumCycle() {` `          ``let min_cycle = Number.MAX_VALUE;` `          ``let E = ``this``.edge.length;` `          ``for` `(let i = 0; i < E; i++) {` `            ``// current Edge information` `            ``let e = ``new` `Edge();` `            ``e = ``this``.edge[i];` `           `  `            ``// get current edge vertices which we currently` `            ``// remove from graph and then find shortest path` `            ``// between these two vertex using Dijkstraâ€™s` `            ``// shortest path algorithm .` `            ``this``.removeEdge(e.u, e.v, e.weight);`   `            ``// minimum distance between these two vertices` `            ``let distance = ``this``.ShortestPath(e.u, e.v);`   `            ``// to make a cycle we have to add weight of` `            ``// currently removed edge if this is the shortest` `            ``// cycle then update min_cycle` `            ``min_cycle = Math.min(min_cycle, distance + e.weight);`   `            ``// add current edge back to the graph` `            ``this``.addEdge(e.u, e.v, e.weight);` `          ``}`   `          ``// return shortest cycle` `          ``return` `min_cycle;` `        ``}` `      ``}`   `      ``// driver program to test above function`   `      ``let V = 9;` `      ``let g = ``new` `Graph(V);`   `      ``// making above shown graph` `      ``g.addEdge(0, 1, 4);` `      ``g.addEdge(0, 7, 8);` `      ``g.addEdge(1, 2, 8);` `      ``g.addEdge(1, 7, 11);` `      ``g.addEdge(2, 3, 7);` `      ``g.addEdge(2, 8, 2);` `      ``g.addEdge(2, 5, 4);` `      ``g.addEdge(3, 4, 9);` `      ``g.addEdge(3, 5, 14);` `      ``g.addEdge(4, 5, 10);` `      ``g.addEdge(5, 6, 2);` `      ``g.addEdge(6, 7, 1);` `      ``g.addEdge(6, 8, 6);` `      ``g.addEdge(7, 8, 7);`   `      ``console.log(g.FindMinimumCycle());` `      `  `      ``// This code is contributed by satwiksuman.`

Output

`14`

Time Complexity: O( E ( E log V ) )

Space Complexity : O(V^2)

For every edge, we run Dijkstra’s shortest path algorithm so over all time complexity E2logV.
In set 2 | we will discuss optimize the algorithm to find a minimum weight cycle in undirected graph.

Previous
Next