Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Problems on Graph
  • Practice Graph
  • MCQs on Graph
  • Graph Tutorial
  • Graph Representation
  • Graph Properties
  • Types of Graphs
  • Graph Applications
  • BFS on Graph
  • DFS on Graph
  • Graph VS Tree
  • Transpose Graph
  • Dijkstra's Algorithm
  • Minimum Spanning Tree
  • Prim’s Algorithm
  • Topological Sorting
  • Floyd Warshall Algorithm
  • Strongly Connected Components
  • Advantages & Disadvantages
Open In App

Number of single cycle components in an undirected graph

Last Updated : 29 Mar, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a set of 'n' vertices and 'm' edges of an undirected simple graph (no parallel edges and no self-loop), find the number of single-cycle components present in the graph. A single-cyclic component is a graph of n nodes containing a single cycle through all nodes of the component.

Example: 

Let us consider the following graph with 15 vertices.

Input: V = 15, E = 14         1 10  // edge 1         1 5   // edge 2         5 10  // edge 3         2 9   // ..         9 15  // ..         2 15  // ..         2 12  // ..         12 15 // ..         13 8  // ..         6 14  // ..         14 3  // ..         3 7   // ..         7 11  // edge 13         11 6  // edge 14  Output :2  In the above-mentioned example, the two   single-cyclic-components are composed of   vertices (1, 10, 5) and (6, 11, 7, 3, 14)   respectively.

Now we can easily see that a single-cycle-component is a connected component where every vertex has the degree as two. 
Therefore, in order to solve this problem we first identify all the connected components of the disconnected graph. For this, we use a depth-first search algorithm. For the DFS algorithm to work, it is required to maintain an array 'found' to keep an account of all the vertices that have been discovered by the recursive function DFS. Once all the elements of a particular connected component are discovered (like vertices(9, 2, 15, 12) form a connected graph component ), we check if all the vertices in the component are having a degree equal to two. If yes, we increase the counter variable 'count' which denotes the number of single-cycle components found in the given graph. To keep an account of the component we are presently dealing with, we may use a vector array 'curr_graph' as well.

C++ 
// CPP program to find single cycle components // in a graph. #include <bits/stdc++.h> using namespace std;  const int N = 100000;  // degree of all the vertices int degree[N];  // to keep track of all the vertices covered  // till now bool found[N];  // all the vertices in a particular  // connected component of the graph vector<int> curr_graph;  // adjacency list vector<int> adj_list[N];  // depth-first traversal to identify all the // nodes in a particular connected graph  // component void DFS(int v) {     found[v] = true;     curr_graph.push_back(v);     for (int it : adj_list[v])         if (!found[it])             DFS(it); }  // function to add an edge in the graph void addEdge(vector<int> adj_list[N], int src,              int dest) {     // for index decrement both src and dest.     src--, dest--;     adj_list[src].push_back(dest);     adj_list[dest].push_back(src);     degree[src]++;     degree[dest]++; }  int countSingleCycles(int n, int m) {     // count of cycle graph components     int count = 0;     for (int i = 0; i < n; ++i) {         if (!found[i]) {             curr_graph.clear();             DFS(i);              // traversing the nodes of the             // current graph component             int flag = 1;             for (int v : curr_graph) {                 if (degree[v] == 2)                     continue;                 else {                     flag = 0;                     break;                 }             }             if (flag == 1) {                 count++;             }         }     }     return(count); }  int main() {     // n->number of vertices     // m->number of edges     int n = 15, m = 14;     addEdge(adj_list, 1, 10);     addEdge(adj_list, 1, 5);     addEdge(adj_list, 5, 10);     addEdge(adj_list, 2, 9);     addEdge(adj_list, 9, 15);     addEdge(adj_list, 2, 15);     addEdge(adj_list, 2, 12);     addEdge(adj_list, 12, 15);     addEdge(adj_list, 13, 8);     addEdge(adj_list, 6, 14);     addEdge(adj_list, 14, 3);     addEdge(adj_list, 3, 7);     addEdge(adj_list, 7, 11);     addEdge(adj_list, 11, 6);      cout << countSingleCycles(n, m);      return 0; }
Java 
// Java program to find single cycle components  // in a graph.  import java.util.*;  class GFG {  static int N = 100000;   // degree of all the vertices  static int degree[] = new int[N];   // to keep track of all the vertices covered  // till now  static boolean found[] = new boolean[N];   // all the vertices in a particular  // connected component of the graph  static Vector<Integer> curr_graph = new Vector<Integer>();   // adjacency list  static Vector<Vector<Integer>> adj_list = new Vector<Vector<Integer>>();   // depth-first traversal to identify all the  // nodes in a particular connected graph  // component  static void DFS(int v)  {      found[v] = true;      curr_graph.add(v);      for (int it = 0 ;it < adj_list.get(v).size(); it++)          if (!found[adj_list.get(v).get(it)])              DFS(adj_list.get(v).get(it));  }   // function to add an edge in the graph  static void addEdge( int src,int dest)  {      // for index decrement both src and dest.      src--; dest--;      adj_list.get(src).add(dest);      adj_list.get(dest).add(src);      degree[src]++;      degree[dest]++;  }   static int countSingleCycles(int n, int m)  {      // count of cycle graph components      int count = 0;      for (int i = 0; i < n; ++i)      {           if (!found[i])         {              curr_graph.clear();                           DFS(i);               // traversing the nodes of the              // current graph component              int flag = 1;              for (int v = 0 ; v < curr_graph.size(); v++)              {                  if (degree[curr_graph.get(v)] == 2)                      continue;                  else                  {                      flag = 0;                      break;                  }              }              if (flag == 1)              {                  count++;              }          }      }      return(count);  }   // Driver code public static void main(String args[]) {           for(int i = 0; i < N + 1; i++)     adj_list.add(new Vector<Integer>());          // n->number of vertices      // m->number of edges      int n = 15, m = 14;      addEdge( 1, 10);      addEdge( 1, 5);      addEdge( 5, 10);      addEdge( 2, 9);      addEdge( 9, 15);      addEdge( 2, 15);      addEdge( 2, 12);      addEdge( 12, 15);      addEdge( 13, 8);      addEdge( 6, 14);      addEdge( 14, 3);      addEdge( 3, 7);      addEdge( 7, 11);      addEdge( 11, 6);            System.out.println(countSingleCycles(n, m));  } }   // This code is contributed by Arnab Kundu
Python3 
# Python3 program to find single  # cycle components in a graph.  N = 100000  # degree of all the vertices  degree = [0] * N   # to keep track of all the  # vertices covered till now  found = [None] * N   # All the vertices in a particular  # connected component of the graph  curr_graph = []   # adjacency list  adj_list = [[] for i in range(N)]   # depth-first traversal to identify  # all the nodes in a particular  # connected graph component  def DFS(v):       found[v] = True     curr_graph.append(v)          for it in adj_list[v]:          if not found[it]:              DFS(it)   # function to add an edge in the graph  def addEdge(adj_list, src, dest):       # for index decrement both src and dest.      src, dest = src - 1, dest - 1     adj_list[src].append(dest)      adj_list[dest].append(src)      degree[src] += 1     degree[dest] += 1  def countSingleCycles(n, m):       # count of cycle graph components      count = 0     for i in range(0, n):          if not found[i]:              curr_graph.clear()              DFS(i)               # traversing the nodes of the              # current graph component              flag = 1             for v in curr_graph:                  if degree[v] == 2:                      continue                 else:                      flag = 0                     break                              if flag == 1:                  count += 1          return count   # Driver Code if __name__ == "__main__":      # n->number of vertices      # m->number of edges      n, m = 15, 14     addEdge(adj_list, 1, 10)      addEdge(adj_list, 1, 5)      addEdge(adj_list, 5, 10)      addEdge(adj_list, 2, 9)      addEdge(adj_list, 9, 15)      addEdge(adj_list, 2, 15)      addEdge(adj_list, 2, 12)      addEdge(adj_list, 12, 15)      addEdge(adj_list, 13, 8)      addEdge(adj_list, 6, 14)      addEdge(adj_list, 14, 3)      addEdge(adj_list, 3, 7)      addEdge(adj_list, 7, 11)      addEdge(adj_list, 11, 6)       print(countSingleCycles(n, m))   # This code is contributed by Rituraj Jain
C# 
// C# program to find single cycle components  // in a graph.  using System; using System.Collections.Generic;      class GFG { static int N = 100000;   // degree of all the vertices  static int []degree = new int[N];   // to keep track of all the vertices covered  // till now  static bool []found = new bool[N];   // all the vertices in a particular  // connected component of the graph  static List<int> curr_graph = new List<int>();   // adjacency list  static List<List<int>> adj_list = new List<List<int>>();   // depth-first traversal to identify all the  // nodes in a particular connected graph  // component  static void DFS(int v)  {      found[v] = true;      curr_graph.Add(v);      for (int it = 0; it < adj_list[v].Count; it++)          if (!found[adj_list[v][it]])              DFS(adj_list[v][it]);  }   // function to add an edge in the graph  static void addEdge(int src,int dest)  {      // for index decrement both src and dest.      src--; dest--;      adj_list[src].Add(dest);      adj_list[dest].Add(src);      degree[src]++;      degree[dest]++;  }   static int countSingleCycles(int n, int m)  {      // count of cycle graph components      int count = 0;      for (int i = 0; i < n; ++i)      {          if (!found[i])         {              curr_graph.Clear();                           DFS(i);               // traversing the nodes of the              // current graph component              int flag = 1;              for (int v = 0 ; v < curr_graph.Count; v++)              {                  if (degree[curr_graph[v]] == 2)                      continue;                  else                 {                      flag = 0;                      break;                  }              }              if (flag == 1)              {                  count++;              }          }      }      return(count);  }   // Driver code public static void Main(String []args) {      for(int i = 0; i < N + 1; i++)     adj_list.Add(new List<int>());          // n->number of vertices      // m->number of edges      int n = 15, m = 14;      addEdge(1, 10);      addEdge(1, 5);      addEdge(5, 10);      addEdge(2, 9);      addEdge(9, 15);      addEdge(2, 15);      addEdge(2, 12);      addEdge(12, 15);      addEdge(13, 8);      addEdge(6, 14);      addEdge(14, 3);      addEdge(3, 7);      addEdge(7, 11);      addEdge(11, 6);           Console.WriteLine(countSingleCycles(n, m));  } }   // This code is contributed by PrinciRaj1992
JavaScript 
<script>  // JavaScript program to find single cycle components  // in a graph.   let N = 100000;   // degree of all the vertices  let degree=new Array(N); for(let i=0;i<N;i++)     degree[i]=0; // to keep track of all the vertices covered  // till now  let found=new Array(N); for(let i=0;i<N;i++)     found[i]=0;  // all the vertices in a particular  // connected component of the graph  let curr_graph = [];  // adjacency list  let adj_list = [];  // depth-first traversal to identify all the  // nodes in a particular connected graph  // component  function DFS(v) {     found[v] = true;      curr_graph.push(v);      for (let it = 0 ;it < adj_list[v].length; it++)          if (!found[adj_list[v][it]])              DFS(adj_list[v][it]);  }  // function to add an edge in the graph  function addEdge(src,dest) {     // for index decrement both src and dest.      src--; dest--;      adj_list[src].push(dest);      adj_list[dest].push(src);      degree[src]++;      degree[dest]++;  }  function countSingleCycles(n,m) {     // count of cycle graph components      let count = 0;      for (let i = 0; i < n; ++i)      {             if (!found[i])         {              curr_graph=[];                             DFS(i);                 // traversing the nodes of the              // current graph component              let flag = 1;              for (let v = 0 ; v < curr_graph.length; v++)              {                  if (degree[curr_graph[v]] == 2)                      continue;                  else                  {                      flag = 0;                      break;                  }              }              if (flag == 1)              {                  count++;              }          }      }      return(count);  }  // Driver code for(let i = 0; i < N + 1; i++)     adj_list.push([]);  // n->number of vertices  // m->number of edges  let n = 15, m = 14;  addEdge( 1, 10);  addEdge( 1, 5);  addEdge( 5, 10);  addEdge( 2, 9);  addEdge( 9, 15);  addEdge( 2, 15);  addEdge( 2, 12);  addEdge( 12, 15);  addEdge( 13, 8);  addEdge( 6, 14);  addEdge( 14, 3);  addEdge( 3, 7);  addEdge( 7, 11);  addEdge( 11, 6);    document.write(countSingleCycles(n, m));   // This code is contributed by avanitrachhadiya2155  </script>

Output: 
2

 

Time Complexity: O(N+M) where N is the number of vertices and M is the number of edges in the graph.
Auxiliary Space: O(N + M)


P
PiyushKumar
Improve
Article Tags :
  • Graph
  • Greedy
  • C++ Programs
  • C++
  • DSA
Practice Tags :
  • CPP
  • Graph
  • Greedy

Similar Reads

    Greedy Algorithms
    Greedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
    3 min read
    Greedy Algorithm Tutorial
    Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Greedy algorithms are used for optimization problems. An optimization problem can be solved using Greedy if the problem has the following pro
    9 min read
    Greedy Algorithms General Structure
    A greedy algorithm solves problems by making the best choice at each step. Instead of looking at all possible solutions, it focuses on the option that seems best right now.Example of Greedy Algorithm - Fractional KnapsackProblem structure:Most of the problems where greedy algorithms work follow thes
    5 min read
    Difference between Greedy Algorithm and Divide and Conquer Algorithm
    Greedy algorithm and divide and conquer algorithm are two common algorithmic paradigms used to solve problems. The main difference between them lies in their approach to solving problems. Greedy Algorithm:The greedy algorithm is an algorithmic paradigm that follows the problem-solving heuristic of m
    3 min read
    Greedy Approach vs Dynamic programming
    Greedy approach and Dynamic programming are two different algorithmic approaches that can be used to solve optimization problems. Here are the main differences between these two approaches: Greedy Approach:The greedy approach makes the best choice at each step with the hope of finding a global optim
    2 min read
    Comparison among Greedy, Divide and Conquer and Dynamic Programming algorithm
    Greedy algorithm, divide and conquer algorithm, and dynamic programming algorithm are three common algorithmic paradigms used to solve problems. Here's a comparison among these algorithms:Approach:Greedy algorithm: Makes locally optimal choices at each step with the hope of finding a global optimum.
    4 min read

    Standard Greedy algorithms

    Activity Selection Problem | Greedy Algo-1
    Given n activities with start times in start[] and finish times in finish[], find the maximum number of activities a single person can perform without overlap. A person can only do one activity at a time. Examples: Input: start[] = [1, 3, 0, 5, 8, 5], finish[] = [2, 4, 6, 7, 9, 9]Output: 4Explanatio
    13 min read
    Job Sequencing Problem
    Given two arrays: deadline[] and profit[], where the index of deadline[] represents a job ID, and deadline[i] denotes the deadline for that job and profit[i] represents profit of doing ith job. Each job takes exactly one unit of time to complete, and only one job can be scheduled at a time. A job ea
    13 min read
    Huffman Coding | Greedy Algo-3
    Huffman coding is a lossless data compression algorithm. The idea is to assign variable-length codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The variable-length codes assigned to input characters are Prefix Codes, means the codes (
    12 min read
    Huffman Decoding
    We have discussed Huffman Encoding in a previous post. In this post, decoding is discussed. Examples: Input Data: AAAAAABCCCCCCDDEEEEEFrequencies: A: 6, B: 1, C: 6, D: 2, E: 5 Encoded Data: 0000000000001100101010101011111111010101010 Huffman Tree: '#' is the special character usedfor internal nodes
    15 min read
    Water Connection Problem
    You are given n houses in a colony, numbered from 1 to n, and p pipes connecting these houses. Each house has at most one outgoing pipe and at most one incoming pipe. Your goal is to install tanks and taps efficiently.A tank is installed at a house that has one outgoing pipe but no incoming pipe.A t
    8 min read
    Greedy Algorithm for Egyptian Fraction
    Every positive fraction can be represented as sum of unique unit fractions. A fraction is unit fraction if numerator is 1 and denominator is a positive integer, for example 1/3 is a unit fraction. Such a representation is called Egyptian Fraction as it was used by ancient Egyptians. Following are a
    11 min read
    Policemen catch thieves
    Given an array arr, where each element represents either a policeman (P) or a thief (T). The objective is to determine the maximum number of thieves that can be caught under the following conditions:Each policeman (P) can catch only one thief (T).A policeman can only catch a thief if the distance be
    12 min read
    Fitting Shelves Problem
    Given length of wall w and shelves of two lengths m and n, find the number of each type of shelf to be used and the remaining empty space in the optimal solution so that the empty space is minimum. The larger of the two shelves is cheaper so it is preferred. However cost is secondary and first prior
    9 min read
    Assign Mice to Holes
    There are N Mice and N holes are placed in a straight line. Each hole can accommodate only 1 mouse. A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x -1. Any of these moves consumes 1 minute. Assign mice to holes so that the time when the last m
    8 min read

    Greedy algorithm on Array

    Minimum product subset of an array
    INTRODUCTION: The minimum product subset of an array refers to a subset of elements from the array such that the product of the elements in the subset is minimized. To find the minimum product subset, various algorithms can be used, such as greedy algorithms, dynamic programming, and branch and boun
    13 min read
    Maximize array sum after K negations using Sorting
    Given an array of size n and an integer k. We must modify array k number of times. In each modification, we can replace any array element arr[i] by -arr[i]. The task is to perform this operation in such a way that after k operations, the sum of the array is maximum.Examples : Input : arr[] = [-2, 0,
    10 min read
    Minimum sum of product of two arrays
    Find the minimum sum of Products of two arrays of the same size, given that k modifications are allowed on the first array. In each modification, one array element of the first array can either be increased or decreased by 2.Examples: Input : a[] = {1, 2, -3} b[] = {-2, 3, -5} k = 5 Output : -31 Exp
    14 min read
    Minimum sum of absolute difference of pairs of two arrays
    Given two arrays a[] and b[] of equal length n. The task is to pair each element of array a to an element in array b, such that sum S of absolute differences of all the pairs is minimum.Suppose, two elements a[i] and a[j] (i != j) of a are paired with elements b[p] and b[q] of b respectively, then p
    7 min read
    Minimum increment/decrement to make array non-Increasing
    Given an array a, your task is to convert it into a non-increasing form such that we can either increment or decrement the array value by 1 in the minimum changes possible. Examples : Input : a[] = {3, 1, 2, 1}Output : 1Explanation : We can convert the array into 3 1 1 1 by changing 3rd element of a
    11 min read
    Sorting array with reverse around middle
    Consider the given array arr[], we need to find if we can sort array with the given operation. The operation is We have to select a subarray from the given array such that the middle element(or elements (in case of even number of elements)) of subarray is also the middle element(or elements (in case
    6 min read
    Sum of Areas of Rectangles possible for an array
    Given an array, the task is to compute the sum of all possible maximum area rectangles which can be formed from the array elements. Also, you can reduce the elements of the array by at most 1. Examples: Input: a = {10, 10, 10, 10, 11, 10, 11, 10} Output: 210 Explanation: We can form two rectangles o
    13 min read
    Largest lexicographic array with at-most K consecutive swaps
    Given an array arr[], find the lexicographically largest array that can be obtained by performing at-most k consecutive swaps. Examples : Input : arr[] = {3, 5, 4, 1, 2} k = 3 Output : 5, 4, 3, 2, 1 Explanation : Array given : 3 5 4 1 2 After swap 1 : 5 3 4 1 2 After swap 2 : 5 4 3 1 2 After swap 3
    9 min read
    Partition into two subsets of lengths K and (N - k) such that the difference of sums is maximum
    Given an array of non-negative integers of length N and an integer K. Partition the given array into two subsets of length K and N - K so that the difference between the sum of both subsets is maximum. Examples : Input : arr[] = {8, 4, 5, 2, 10} k = 2 Output : 17 Explanation : Here, we can make firs
    7 min read

    Greedy algorithm on Operating System

    Program for First Fit algorithm in Memory Management
    Prerequisite : Partition Allocation MethodsIn the first fit, the partition is allocated which is first sufficient from the top of Main Memory.Example : Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426};Output:Process No. Process Size Block no. 1 212 2 2 417 5 3 11
    8 min read
    Program for Best Fit algorithm in Memory Management
    Prerequisite : Partition allocation methodsBest fit allocates the process to a partition which is the smallest sufficient partition among the free available partitions. Example: Input : blockSize[] = {100, 500, 200, 300, 600}; processSize[] = {212, 417, 112, 426}; Output: Process No. Process Size Bl
    8 min read
    Program for Worst Fit algorithm in Memory Management
    Prerequisite : Partition allocation methodsWorst Fit allocates a process to the partition which is largest sufficient among the freely available partitions available in the main memory. If a large process comes at a later stage, then memory will not have space to accommodate it. Example: Input : blo
    8 min read
    Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)
    The shortest job first (SJF) or shortest job next, is a scheduling policy that selects the waiting process with the smallest execution time to execute next. SJN, also known as Shortest Job Next (SJN), can be preemptive or non-preemptive.   Characteristics of SJF Scheduling: Shortest Job first has th
    13 min read
    Job Scheduling with two jobs allowed at a time
    Given a 2d array jobs[][] of order n * 2, where each element jobs[i], contains two integers, representing the start and end time of the job. Your task is to check if it is possible to complete all the jobs, provided that two jobs can be done simultaneously at a particular moment. Note: If a job star
    6 min read
    Optimal Page Replacement Algorithm
    In operating systems, whenever a new page is referred and not present in memory, page fault occurs, and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorit
    3 min read

    Greedy algorithm on Graph

    Prim’s Algorithm for Minimum Spanning Tree (MST)
    Prim’s algorithm is a Greedy algorithm like Kruskal's algorithm. This algorithm always starts with a single node and moves through several adjacent nodes, in order to explore all of the connected edges along the way.The algorithm starts with an empty spanning tree. The idea is to maintain two sets o
    15+ min read
    Boruvka's algorithm | Greedy Algo-9
    We have discussed the following topics on Minimum Spanning Tree.Applications of Minimum Spanning Tree Problem Kruskal’s Minimum Spanning Tree Algorithm Prim’s Minimum Spanning Tree AlgorithmIn this post, Boruvka's algorithm is discussed. Like Prim's and Kruskal's, Boruvka’s algorithm is also a Greed
    15+ min read
    Dial's Algorithm (Optimized Dijkstra for small range weights)
    Given a weighted Graph and a source vertex, the task is to find the shortest paths from the source node to all other vertices.Example:Input : n = 9, src = 0Output : 0 4 12 19 21 11 9 8 14 We have learned about how to find the shortest path from a given source vertex to all other vertex using Dijkstr
    10 min read
    Minimum cost to connect all cities
    There are n cities and there are roads in between some of the cities. Somehow all the roads are damaged simultaneously. We have to repair the roads to connect the cities again. There is a fixed cost to repair a particular road.Input is in the form of edges {u, v, w} where, u and v are city indices.
    7 min read
    Number of single cycle components in an undirected graph
    Given a set of 'n' vertices and 'm' edges of an undirected simple graph (no parallel edges and no self-loop), find the number of single-cycle components present in the graph. A single-cyclic component is a graph of n nodes containing a single cycle through all nodes of the component. Example: Let us
    9 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences