# Shortest cycle in an undirected unweighted graph

• Difficulty Level : Hard
• Last Updated : 02 Jul, 2021

Given an undirected unweighted graph. The task is to find the length of the shortest cycle in the given graph. If no cycle exists print -1.

Examples:

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.

Input:

Output:
Cycle 6 -> 1 -> 5 -> 0 -> 6

Input:

Output:
Cycle 6 -> 1 -> 2 -> 6

Prerequisites: Dijkstra

Approach: For every vertex, we check if it is possible to get the shortest cycle involving this vertex. For every vertex first, push current vertex into the queue and then it’s neighbours and if the vertex which is already visited comes again then the cycle is present.
Apply the above process for every vertex and get the length of the shortest cycle.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define N 100200` `vector<``int``> gr[N];` `// Function to add edge``void` `Add_edge(``int` `x, ``int` `y)``{``    ``gr[x].push_back(y);``    ``gr[y].push_back(x);``}` `// Function to find the length of``// the shortest cycle in the graph``int` `shortest_cycle(``int` `n)``{``    ``// To store length of the shortest cycle``    ``int` `ans = INT_MAX;` `    ``// For all vertices``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Make distance maximum``        ``vector<``int``> dist(n, (``int``)(1e9));` `        ``// Take a imaginary parent``        ``vector<``int``> par(n, -1);` `        ``// Distance of source to source is 0``        ``dist[i] = 0;``        ``queue<``int``> q;` `        ``// Push the source element``        ``q.push(i);` `        ``// Continue until queue is not empty``        ``while` `(!q.empty()) {` `            ``// Take the first element``            ``int` `x = q.front();``            ``q.pop();` `            ``// Traverse for all it's childs``            ``for` `(``int` `child : gr[x]) {` `                ``// If it is not visited yet``                ``if` `(dist[child] == (``int``)(1e9)) {` `                    ``// Increase distance by 1``                    ``dist[child] = 1 + dist[x];` `                    ``// Change parent``                    ``par[child] = x;` `                    ``// Push into the queue``                    ``q.push(child);``                ``}` `                ``// If it is already visited``                ``else` `if` `(par[x] != child and par[child] != x)``                    ``ans = min(ans, dist[x] + dist[child] + 1);``            ``}``        ``}``    ``}` `    ``// If graph contains no cycle``    ``if` `(ans == INT_MAX)``        ``return` `-1;` `    ``// If graph contains cycle``    ``else``        ``return` `ans;``}` `// Driver code``int` `main()``{``    ``// Number of vertices``    ``int` `n = 7;` `    ``// Add edges``    ``Add_edge(0, 6);``    ``Add_edge(0, 5);``    ``Add_edge(5, 1);``    ``Add_edge(1, 6);``    ``Add_edge(2, 6);``    ``Add_edge(2, 3);``    ``Add_edge(3, 4);``    ``Add_edge(4, 1);` `    ``// Function call``    ``cout << shortest_cycle(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `    ``static` `final` `int` `N = ``100200``;``    ``@SuppressWarnings``(``"unchecked"``)``    ``static` `Vector[] gr = ``new` `Vector[N];` `    ``// Function to add edge``    ``static` `void` `Add_edge(``int` `x, ``int` `y)``    ``{``        ``gr[x].add(y);``        ``gr[y].add(x);``    ``}` `    ``// Function to find the length of``    ``// the shortest cycle in the graph``    ``static` `int` `shortest_cycle(``int` `n)``    ``{` `        ``// To store length of the shortest cycle``        ``int` `ans = Integer.MAX_VALUE;` `        ``// For all vertices``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// Make distance maximum``            ``int``[] dist = ``new` `int``[n];``            ``Arrays.fill(dist, (``int``) 1e9);` `            ``// Take a imaginary parent``            ``int``[] par = ``new` `int``[n];``            ``Arrays.fill(par, -``1``);` `            ``// Distance of source to source is 0``            ``dist[i] = ``0``;``            ``Queue q = ``new` `LinkedList<>();` `            ``// Push the source element``            ``q.add(i);` `            ``// Continue until queue is not empty``            ``while` `(!q.isEmpty())``            ``{` `                ``// Take the first element``                ``int` `x = q.poll();` `                ``// Traverse for all it's childs``                ``for` `(``int` `child : gr[x])``                ``{``                    ``// If it is not visited yet``                    ``if` `(dist[child] == (``int``) (1e9))``                    ``{` `                        ``// Increase distance by 1``                        ``dist[child] = ``1` `+ dist[x];` `                        ``// Change parent``                        ``par[child] = x;` `                        ``// Push into the queue``                        ``q.add(child);``                    ``} ``else` `if` `(par[x] != child && par[child] != x)``                        ``ans = Math.min(ans, dist[x] + dist[child] + ``1``);``                ``}``            ``}``        ``}` `        ``// If graph contains no cycle``        ``if` `(ans == Integer.MAX_VALUE)``            ``return` `-``1``;` `        ``// If graph contains cycle``        ``else``            ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``for` `(``int` `i = ``0``; i < N; i++)``            ``gr[i] = ``new` `Vector<>();` `        ``// Number of vertices``        ``int` `n = ``7``;` `        ``// Add edges``        ``Add_edge(``0``, ``6``);``        ``Add_edge(``0``, ``5``);``        ``Add_edge(``5``, ``1``);``        ``Add_edge(``1``, ``6``);``        ``Add_edge(``2``, ``6``);``        ``Add_edge(``2``, ``3``);``        ``Add_edge(``3``, ``4``);``        ``Add_edge(``4``, ``1``);` `        ``// Function call``        ``System.out.println(shortest_cycle(n));``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python3 implementation of the approach``from` `sys ``import` `maxsize as INT_MAX``from` `collections ``import` `deque` `N ``=` `100200` `gr ``=` `[``0``] ``*` `N``for` `i ``in` `range``(N):``    ``gr[i] ``=` `[]` `# Function to add edge``def` `add_edge(x: ``int``, y: ``int``) ``-``> ``None``:``    ``global` `gr``    ``gr[x].append(y)``    ``gr[y].append(x)` `# Function to find the length of``# the shortest cycle in the graph``def` `shortest_cycle(n: ``int``) ``-``> ``int``:` `    ``# To store length of the shortest cycle``    ``ans ``=` `INT_MAX` `    ``# For all vertices``    ``for` `i ``in` `range``(n):` `        ``# Make distance maximum``        ``dist ``=` `[``int``(``1e9``)] ``*` `n` `        ``# Take a imaginary parent``        ``par ``=` `[``-``1``] ``*` `n` `        ``# Distance of source to source is 0``        ``dist[i] ``=` `0``        ``q ``=` `deque()` `        ``# Push the source element``        ``q.append(i)` `        ``# Continue until queue is not empty``        ``while` `q:` `            ``# Take the first element``            ``x ``=` `q[``0``]``            ``q.popleft()` `            ``# Traverse for all it's childs``            ``for` `child ``in` `gr[x]:` `                ``# If it is not visited yet``                ``if` `dist[child] ``=``=` `int``(``1e9``):` `                    ``# Increase distance by 1``                    ``dist[child] ``=` `1` `+` `dist[x]` `                    ``# Change parent``                    ``par[child] ``=` `x` `                    ``# Push into the queue``                    ``q.append(child)` `                ``# If it is already visited``                ``elif` `par[x] !``=` `child ``and` `par[child] !``=` `x:``                    ``ans ``=` `min``(ans, dist[x] ``+``                                   ``dist[child] ``+` `1``)` `    ``# If graph contains no cycle``    ``if` `ans ``=``=` `INT_MAX:``        ``return` `-``1` `    ``# If graph contains cycle``    ``else``:``        ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Number of vertices``    ``n ``=` `7` `    ``# Add edges``    ``add_edge(``0``, ``6``)``    ``add_edge(``0``, ``5``)``    ``add_edge(``5``, ``1``)``    ``add_edge(``1``, ``6``)``    ``add_edge(``2``, ``6``)``    ``add_edge(``2``, ``3``)``    ``add_edge(``3``, ``4``)``    ``add_edge(``4``, ``1``)` `    ``# Function call``    ``print``(shortest_cycle(n))` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `    ``static` `readonly` `int` `N = 100200;``    ``static` `List<``int``>[] gr = ``new` `List<``int``>[N];` `    ``// Function to add edge``    ``static` `void` `Add_edge(``int` `x, ``int` `y)``    ``{``        ``gr[x].Add(y);``        ``gr[y].Add(x);``    ``}` `    ``// Function to find the length of``    ``// the shortest cycle in the graph``    ``static` `int` `shortest_cycle(``int` `n)``    ``{` `        ``// To store length of the shortest cycle``        ``int` `ans = ``int``.MaxValue;` `        ``// For all vertices``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// Make distance maximum``            ``int``[] dist = ``new` `int``[n];``            ``fill(dist, (``int``) 1e9);` `            ``// Take a imaginary parent``            ``int``[] par = ``new` `int``[n];``            ``fill(par, -1);` `            ``// Distance of source to source is 0``            ``dist[i] = 0;``            ``List<``int``> q = ``new` `List<``int``>();` `            ``// Push the source element``            ``q.Add(i);` `            ``// Continue until queue is not empty``            ``while` `(q.Count!=0)``            ``{` `                ``// Take the first element``                ``int` `x = q[0];``                ``q.RemoveAt(0);` `                ``// Traverse for all it's childs``                ``foreach` `(``int` `child ``in` `gr[x])``                ``{``                    ``// If it is not visited yet``                    ``if` `(dist[child] == (``int``) (1e9))``                    ``{` `                        ``// Increase distance by 1``                        ``dist[child] = 1 + dist[x];` `                        ``// Change parent``                        ``par[child] = x;` `                        ``// Push into the queue``                        ``q.Add(child);``                    ``} ``else` `if` `(par[x] != child && par[child] != x)``                        ``ans = Math.Min(ans, dist[x] + dist[child] + 1);``                ``}``            ``}``        ``}` `        ``// If graph contains no cycle``        ``if` `(ans == ``int``.MaxValue)``            ``return` `-1;` `        ``// If graph contains cycle``        ``else``            ``return` `ans;``    ``}``    ``static` `int``[] fill(``int` `[]arr, ``int` `val)``    ``{``        ``for``(``int` `i = 0;i();` `        ``// Number of vertices``        ``int` `n = 7;` `        ``// Add edges``        ``Add_edge(0, 6);``        ``Add_edge(0, 5);``        ``Add_edge(5, 1);``        ``Add_edge(1, 6);``        ``Add_edge(2, 6);``        ``Add_edge(2, 3);``        ``Add_edge(3, 4);``        ``Add_edge(4, 1);` `        ``// Function call``        ``Console.WriteLine(shortest_cycle(n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`4`

My Personal Notes arrow_drop_up