Given an **undirected graph** consisting of **N** vertices numbered **[0, N-1]** and **E** edges, the task is to count the number of cycles such that any subset of vertices of a cycle does not form another cycle.**Examples:**

Input:N = 2, E = 2, edges = [{0, 1}, {1, 0}]Output:1Explanation:

Only one cycle exists between the two vertices.

Input:N = 6, E = 9, edges = [{0, 1}, {1, 2}, {0, 2}, {3, 0}, {3, 2}, {4, 1}, {4, 2}, {5, 1}, {5, 0}]Output:4Explanation:

The possible cycles are shown in the diagram below:

Cycles such as 5 -> 0 -> 2 -> 1 -> 5 are not considered as it comprises of inner cycles {5 -> 0 -> 1} and {0 -> 1 -> 2}

**Approach:**

Since V vertices require V edges to form 1 cycle, these the number of required cycles can be expressed using the formula:

(Edges - Vertices) + 1

**Illustration:**

N = 6, E = 9, edges = [{0, 1}, {1, 2}, {0, 2}, {3, 0}, {3, 2}, {4, 1}, {4, 2}, {5, 1}, {5, 0}]

Number of Cycles = 9 – 6 + 1 = 4

The 4 cycles in the graph are:

{5, 0, 1}, {0, 1, 2}, {3, 0, 2} and {1, 2, 4}

This formula also covers the case when a single vertex may have a self-loop.

Below is the implementation of the above approach:

## C++

`// C++ implementation for the` `// above approach.` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the` `// count of required cycles` `int` `numberOfCycles(` `int` `N, ` `int` `E,` ` ` `int` `edges[][2])` `{` ` ` `vector<` `int` `> graph[N];` ` ` `for` `(` `int` `i = 0; i < E; i++) {` ` ` `graph[edges[i][0]]` ` ` `.push_back(edges[i][1]);` ` ` `graph[edges[i][1]]` ` ` `.push_back(edges[i][0]);` ` ` `}` ` ` `// Return the number of cycles` ` ` `return` `(E - N) + 1;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 6;` ` ` `int` `E = 9;` ` ` `int` `edges[][2] = { { 0, 1 },` ` ` `{ 1, 2 },` ` ` `{ 2, 0 },` ` ` `{ 5, 1 },` ` ` `{ 5, 0 },` ` ` `{ 3, 0 },` ` ` `{ 3, 2 },` ` ` `{ 4, 2 },` ` ` `{ 4, 1 } };` ` ` `int` `k = numberOfCycles(N, E,` ` ` `edges);` ` ` `cout << k << endl;` ` ` `return` `0;` `}` |

## Java

`// Java implementation for the` `// above approach.` `import` `java.util.*;` `class` `GFG{` `// Function to return the` `// count of required cycles` `static` `int` `numberOfCycles(` `int` `N, ` `int` `E,` ` ` `int` `edges[][])` `{` ` ` `@SuppressWarnings` `(` `"unchecked"` `)` ` ` `Vector<Integer> []graph = ` `new` `Vector[N];` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `graph[i] = ` `new` `Vector<Integer>();` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < E; i++)` ` ` `{` ` ` `graph[edges[i][` `0` `]].add(edges[i][` `1` `]);` ` ` `graph[edges[i][` `1` `]].add(edges[i][` `0` `]);` ` ` `}` ` ` `// Return the number of cycles` ` ` `return` `(E - N) + ` `1` `;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `6` `;` ` ` `int` `E = ` `9` `;` ` ` `int` `edges[][] = { { ` `0` `, ` `1` `},` ` ` `{ ` `1` `, ` `2` `},` ` ` `{ ` `2` `, ` `0` `},` ` ` `{ ` `5` `, ` `1` `},` ` ` `{ ` `5` `, ` `0` `},` ` ` `{ ` `3` `, ` `0` `},` ` ` `{ ` `3` `, ` `2` `},` ` ` `{ ` `4` `, ` `2` `},` ` ` `{ ` `4` `, ` `1` `} };` ` ` ` ` `int` `k = numberOfCycles(N, E, edges);` ` ` `System.out.print(k + ` `"\n"` `);` `}` `}` `// This code is contributed by Amit Katiyar` |

## Python3

`# Python3 implementation for the` `# above approach.` ` ` `# Function to return the` `# count of required cycles` `def` `numberOfCycles(N, E, edges):` ` ` `graph` `=` `[[] ` `for` `i ` `in` `range` `(N)]` ` ` ` ` `for` `i ` `in` `range` `(E):` ` ` ` ` `graph[edges[i][` `0` `]].append(edges[i][` `1` `]);` ` ` `graph[edges[i][` `1` `]].append(edges[i][` `0` `]);` ` ` ` ` `# Return the number of cycles` ` ` `return` `(E ` `-` `N) ` `+` `1` `;` ` ` `# Driver Code` `if` `__name__` `=` `=` `'__main__'` `:` ` ` ` ` `N ` `=` `6` `;` ` ` `E ` `=` `9` `;` ` ` `edges ` `=` `[ [ ` `0` `, ` `1` `],` ` ` `[ ` `1` `, ` `2` `],` ` ` `[ ` `2` `, ` `0` `],` ` ` `[ ` `5` `, ` `1` `],` ` ` `[ ` `5` `, ` `0` `],` ` ` `[ ` `3` `, ` `0` `],` ` ` `[ ` `3` `, ` `2` `],` ` ` `[ ` `4` `, ` `2` `],` ` ` `[ ` `4` `, ` `1` `] ];` ` ` ` ` `k ` `=` `numberOfCycles(N, E,edges);` ` ` `print` `(k)` ` ` ` ` `# This code is contributed by rutvik_56` |

## C#

`// C# implementation for the` `// above approach.` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to return the` `// count of required cycles` `static` `int` `numberOfCycles(` `int` `N, ` `int` `E,` ` ` `int` `[,]edges)` `{` ` ` `List<` `int` `> []graph = ` `new` `List<` `int` `>[N];` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `graph[i] = ` `new` `List<` `int` `>();` ` ` ` ` `for` `(` `int` `i = 0; i < E; i++)` ` ` `{` ` ` `graph[edges[i, 0]].Add(edges[i, 1]);` ` ` `graph[edges[i, 1]].Add(edges[i, 0]);` ` ` `}` ` ` `// Return the number of cycles` ` ` `return` `(E - N) + 1;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `N = 6;` ` ` `int` `E = 9;` ` ` `int` `[,]edges = { { 0, 1 }, { 1, 2 },` ` ` `{ 2, 0 }, { 5, 1 },` ` ` `{ 5, 0 }, { 3, 0 },` ` ` `{ 3, 2 }, { 4, 2 },` ` ` `{ 4, 1 } };` ` ` ` ` `int` `k = numberOfCycles(N, E, edges);` ` ` `Console.Write(k + ` `"\n"` `);` `}` `}` `// This code is contributed by Rohit_ranjan` |

**Output:**

4

**Time Complexity:** O(E) **Auxiliary Space:** O(N)

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 industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**