GFG App
Open App
Browser
Continue

# Find the number of sticks that forms cycle

Given N sticks with two sides Left and Right (represented by 0 and 1). Given 2d array, A[][4] of size M representing operations that have to be performed on these sticks in each operation {A, B, C, D} connect side B (Left or Right) of A’th stick with side D (Left or Right) of C’th stick. The task for this problem is to print a number of sticks that form a cycle.

Examples:

Input: N = 5, A[][4] = {{3,  0, 5, 1}, {5, 0, 3, 1}, {4, 0, 2, 1}}
Output: 1
Explanation:  Given sticks have only one cycle between stick 3 and stick 5.

Representation of example 1

Input:  N = 7, A[][4] = {}
Output:  0

Approach: The following approach can be used to solve the given problem

Depth-First-Search can be used to solve this problem.

• Assuming each stick to be two nodes Left and Right Nodes which are already connected with each other.
• Do DFS() and keep track of previously visited nodes. While traversing if a given node is already visited and it is not the previous node then the cycle exists.
• Keep a counter that tracks the count of cycles.

Follow the steps below to solve the problem:

• Initialize flag with value 0.
• Connect left and right nodes of the same stick by iterating on all N nodes.
• Performing all M operations by filling the adjacency list.
• Creating answer variable ans that is initialized with 0.
• Creating visited array vis[N + 1][2].
• Create a recursive function dfs() that contains two parameters one is the current node and another one is the previously visited node.
• iterating over all N nodes and calling dfs() function for each node.
• If an already visited node is visited and it is not the previous node update the flag to 1.
• At the end add a flag to ans and set the flag again back to zero for the next dfs call.
• Returning the ans variable.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// flag defined for detecting cycle` `int` `flag = 0;`   `// dfs function` `void` `dfs(pair<``int``, ``int``> v, pair<``int``, ``int``> prev,` `         ``vector > > >& adj,` `         ``vector >& vis)` `{`   `    ``// marking current state visited` `    ``vis[v.first][v.second] = 1;`   `    ``// travelling to neibours` `    ``for` `(``auto``& u : adj[v.first][v.second]) {`   `        ``// if not visited` `        ``if` `(!vis[u.first][u.second]) {`   `            ``// call dfs function` `            ``dfs(u, v, adj, vis);` `        ``}`   `        ``// if visited` `        ``else` `if` `(prev != u) {`   `            ``// mark flag 1` `            ``flag = 1;`   `            ``// return dfs` `            ``return``;` `        ``}` `    ``}` `}`   `// Function to count cycles formed by` `// sticks` `int` `countCycles(``int` `N, ``int` `A[][4], ``int` `M)` `{`   `    ``// initializing adjaceny list` `    ``vector > > > adj(` `        ``N + 1, vector > >(2));`   `    ``// Left and Right of same sticks are` `    ``// connected with each other` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``adj[i][0].push_back({ i, 1 });` `        ``adj[i][1].push_back({ i, 0 });` `    ``}`   `    ``// performing all M operations` `    ``for` `(``int` `i = 0; i < M; i++) {` `        ``adj[A[i][0]][A[i][1]].push_back(` `            ``{ A[i][2], A[i][3] });` `        ``adj[A[i][2]][A[i][3]].push_back(` `            ``{ A[i][0], A[i][1] });` `    ``}`   `    ``// answer initialized with zero` `    ``int` `ans = 0;`   `    ``// visited array` `    ``vector > vis(N + 1, vector<``int``>(2, 0));`   `    ``// calling all non visited nodes` `    ``for` `(``int` `i = 1; i <= N; i++) {`   `        ``// if i is not visited` `        ``if` `(!vis[i][0]) {`   `            ``// calling dfs function` `            ``dfs({ i, 0 }, { -1, -1 }, adj, vis);`   `            ``// adding flag to answer` `            ``ans += flag;`   `            ``// resetting flag to zero` `            ``flag = 0;` `        ``}` `    ``}`   `    ``// return total cycles` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Input 1` `    ``int` `N = 5, A[][4] = { { 3, 0, 5, 1 },` `                          ``{ 5, 0, 3, 1 },` `                          ``{ 4, 0, 2, 1 } };` `    ``int` `M = 3;`   `    ``// Function Call` `    ``cout << countCycles(N, A, M) << endl;`   `    ``// Input 2` `    ``int` `N1 = 5, A1[][4] = {};` `    ``int` `M1 = 0;`   `    ``// Function Call` `    ``cout << countCycles(N1, A1, M1) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `import` `java.util.ArrayList;` `import` `java.util.List;`   `public` `class` `GFG {`   `  ``// flag defined for detecting cycle` `  ``static` `int` `flag = ``0``;`   `  ``// dfs function` `  ``static` `void` `dfs(``int``[] v, ``int``[] prev,` `                  ``List > > adj,` `                  ``int``[][] vis)` `  ``{`   `    ``// marking current state visited` `    ``vis[v[``0``]][v[``1``]] = ``1``;`   `    ``// travelling to neibours` `    ``for` `(``int``[] u : adj.get(v[``0``]).get(v[``1``])) {`   `      ``// if not visited` `      ``if` `(vis[u[``0``]][u[``1``]] == ``0``) {`   `        ``// call dfs function` `        ``dfs(u, v, adj, vis);` `      ``}`   `      ``// if visited` `      ``else` `if` `(!(prev[``0``] == u[``0``]` `                 ``&& prev[``1``] == u[``1``])) {`   `        ``// mark flag 1` `        ``flag = ``1``;`   `        ``// return dfs` `        ``return``;` `      ``}` `    ``}` `  ``}`   `  ``// Function to count cycles formed by` `  ``// sticks` `  ``static` `int` `countCycles(``int` `N, ``int``[][] A, ``int` `M)` `  ``{`   `    ``// initializing adjaceny list` `    ``List > > adj = ``new` `ArrayList<>();` `    ``for` `(``int` `i = ``0``; i <= N; i++) {` `      ``List > innerAdj = ``new` `ArrayList<>();` `      ``for` `(``int` `j = ``0``; j < ``2``; j++) {` `        ``innerAdj.add(``new` `ArrayList<>());` `      ``}` `      ``adj.add(innerAdj);` `    ``}`   `    ``// Left and Right of same sticks are` `    ``// connected with each other` `    ``for` `(``int` `i = ``1``; i <= N; i++) {` `      ``int``[] left = { i, ``0` `};` `      ``int``[] right = { i, ``1` `};` `      ``adj.get(i).get(``0``).add(right);` `      ``adj.get(i).get(``1``).add(left);` `    ``}`   `    ``// performing all M operations` `    ``for` `(``int` `i = ``0``; i < M; i++) {` `      ``int``[] left = { A[i][``0``], A[i][``1``] };` `      ``int``[] right = { A[i][``2``], A[i][``3``] };` `      ``adj.get(A[i][``0``]).get(A[i][``1``]).add(right);` `      ``adj.get(A[i][``2``]).get(A[i][``3``]).add(left);` `    ``}`   `    ``// answer initialized with zero` `    ``int` `ans = ``0``;`   `    ``// visited array` `    ``int``[][] vis = ``new` `int``[N + ``1``][``2``];`   `    ``// calling all non visited nodes` `    ``for` `(``int` `i = ``1``; i <= N; i++) {`   `      ``// if i is not visited` `      ``if` `(vis[i][``0``] == ``0``) {`   `        ``// calling dfs function` `        ``dfs(``new` `int``[] { i, ``0` `},` `            ``new` `int``[] { -``1``, -``1` `}, adj, vis);`   `        ``// adding flag to answer` `        ``ans += flag;`   `        ``// resetting flag to zero` `        ``flag = ``0``;` `      ``}` `    ``}`   `    ``// return total cycles` `    ``return` `ans;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{`   `    ``// Input 1` `    ``int` `N = ``5``;` `    ``int``[][] A = { { ``3``, ``0``, ``5``, ``1` `},` `                 ``{ ``5``, ``0``, ``3``, ``1` `},` `                 ``{ ``4``, ``0``, ``2``, ``1` `} };` `    ``int` `M = ``3``;`   `    ``// Function Call` `    ``System.out.println(countCycles(N, A, M));`   `    ``// Input 2` `    ``int` `N1 = ``5``;` `    ``int``[][] A1 = {};` `    ``int` `M1 = ``0``;`   `    ``// Function Call` `    ``System.out.println(countCycles(N1, A1, M1));` `  ``}` `}`   `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Python code to implement the approach`   `# flag defined for detecting cycle` `flag ``=` `0`   `# dfs function` `def` `dfs(v, prev, adj, vis):` `    ``global` `flag`   `    ``# marking current state visited` `    ``vis[v[``0``]][v[``1``]] ``=` `1`   `    ``# travelling to neibours` `    ``for` `u ``in` `adj[v[``0``]][v[``1``]]:` `        ``# if not visited` `        ``if` `not` `vis[u[``0``]][u[``1``]]:` `            ``# call dfs function` `            ``dfs(u, v, adj, vis)` `        ``# if visited` `        ``elif` `prev !``=` `u:` `            ``# mark flag 1` `            ``flag ``=` `1` `            ``# return dfs` `            ``return`   `# Function to count cycles formed by sticks` `def` `countCycles(N, A, M):` `    ``global` `flag`   `    ``# initializing adjaceny list` `    ``adj ``=` `[[[] ``for` `i ``in` `range``(``2``)] ``for` `j ``in` `range``(N``+``1``)]`   `    ``# Left and Right of same sticks are connected with each other` `    ``for` `i ``in` `range``(``1``, N``+``1``):` `        ``adj[i][``0``].append((i, ``1``))` `        ``adj[i][``1``].append((i, ``0``))`   `    ``# performing all M operations` `    ``for` `i ``in` `range``(M):` `        ``adj[A[i][``0``]][A[i][``1``]].append((A[i][``2``], A[i][``3``]))` `        ``adj[A[i][``2``]][A[i][``3``]].append((A[i][``0``], A[i][``1``]))`   `    ``# answer initialized with zero` `    ``ans ``=` `0`   `    ``# visited array` `    ``vis ``=` `[[``0` `for` `i ``in` `range``(``2``)] ``for` `j ``in` `range``(N``+``1``)]`   `    ``# calling all non visited nodes` `    ``for` `i ``in` `range``(``1``, N``+``1``):` `      `  `        ``# if i is not visited` `        ``if` `not` `vis[i][``0``]:` `          `  `            ``# calling dfs function` `            ``dfs((i, ``0``), (``-``1``, ``-``1``), adj, vis)` `            `  `            ``# adding flag to answer` `            ``ans ``+``=` `flag` `            `  `            ``# resetting flag to zero` `            ``flag ``=` `0`   `    ``# return total cycles` `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Input 1` `    ``N ``=` `5` `    ``A ``=` `[[``3``, ``0``, ``5``, ``1``], [``5``, ``0``, ``3``, ``1``], [``4``, ``0``, ``2``, ``1``]]` `    ``M ``=` `3`   `    ``# Function Call` `    ``print``(countCycles(N, A, M))`   `    ``# Input 2` `    ``N1 ``=` `5` `    ``A1 ``=` `[]` `    ``M1 ``=` `0`   `    ``# Function Call` `    ``print``(countCycles(N1, A1, M1))`   `# This code is contributed by Susobhan Akhuli`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `Solution {` `    ``// flag defined for detecting cycle` `    ``static` `int` `flag = 0;`   `    ``// dfs function` `    ``static` `void` `    ``dfs(Tuple<``int``, ``int``> v, Tuple<``int``, ``int``> prev,` `        ``List > > > adj,` `        ``List > vis)` `    ``{` `        ``// marking current state visited` `        ``vis[v.Item1][v.Item2] = 1;`   `        ``// travelling to neighbors` `        ``foreach``(``var` `u ``in` `adj[v.Item1][v.Item2])` `        ``{` `            ``// if not visited` `            ``if` `(vis[u.Item1][u.Item2] == 0) {` `                ``// call dfs function` `                ``dfs(u, v, adj, vis);` `            ``}` `            ``// if visited` `            ``else` `if` `(!prev.Equals(u)) {` `                ``// mark flag 1` `                ``flag = 1;`   `                ``// return dfs` `                ``return``;` `            ``}` `        ``}` `    ``}`   `    ``// Function to count cycles formed by sticks` `    ``static` `int` `countCycles(``int` `N, ``int``[, ] A, ``int` `M)` `    ``{` `        ``// initializing adjacency list` `        ``var` `adj = ``new` `List > > >(` `            ``N + 1);` `        ``for` `(``int` `i = 0; i <= N; i++) {` `            ``adj.Add(``new` `List > >() {` `                ``new` `List >(),` `                    ``new` `List >()` `            ``});` `        ``}`   `        ``// Left and Right of same sticks are` `        ``// connected with each other` `        ``for` `(``int` `i = 1; i <= N; i++) {` `            ``adj[i][0].Add(Tuple.Create(i, 1));` `            ``adj[i][1].Add(Tuple.Create(i, 0));` `        ``}`   `        ``// performing all M operations` `        ``for` `(``int` `i = 0; i < M; i++) {` `            ``adj[A[i, 0]][A[i, 1]].Add(` `                ``Tuple.Create(A[i, 2], A[i, 3]));` `            ``adj[A[i, 2]][A[i, 3]].Add(` `                ``Tuple.Create(A[i, 0], A[i, 1]));` `        ``}`   `        ``// answer initialized with zero` `        ``int` `ans = 0;`   `        ``// visited array` `        ``var` `vis = ``new` `List >();` `        ``for` `(``int` `i = 0; i <= N; i++) {` `            ``vis.Add(``new` `List<``int``>() { 0, 0 });` `        ``}`   `        ``// calling all non visited nodes` `        ``for` `(``int` `i = 1; i <= N; i++) {` `            ``// if i is not visited` `            ``if` `(vis[i][0] == 0) {` `                ``// calling dfs function` `                ``dfs(Tuple.Create(i, 0),` `                    ``Tuple.Create(-1, -1), adj, vis);`   `                ``// adding flag to answer` `                ``ans += flag;`   `                ``// resetting flag to zero` `                ``flag = 0;` `            ``}` `        ``}`   `        ``// return total cycles` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``static` `void` `Main()` `    ``{` `        ``// Input 1` `        ``int` `N = 5;` `        ``int``[, ] A = { { 3, 0, 5, 1 },` `                      ``{ 5, 0, 3, 1 },` `                      ``{ 4, 0, 2, 1 } };` `        ``int` `M = 3;`   `        ``// Function Call` `        ``Console.WriteLine(countCycles(N, A, M));` `        ``int` `N1 = 5;` `        ``int``[, ] A1 = {};` `        ``int` `M1 = 0;` `        ``Console.WriteLine(countCycles(N1, A1, M1));` `    ``}` `}`

## Javascript

 `// JavaScript code to implement the approach` `    `  `// flag defined for detecting cycle` `let flag = 0;`   `// dfs function` `function` `dfs(v, prev, adj, vis) {` `    ``// marking current state visited` `    ``vis[v[0]][v[1]] = 1;`   `    ``// travelling to neighbours` `    ``for` `(let u of adj[v[0]][v[1]]) {` `        ``// if not visited` `        ``if` `(!vis[u[0]][u[1]]) {` `            ``// call dfs function` `            ``dfs(u, v, adj, vis);` `        ``}` `        ``// if visited` `        ``else` `if` `(prev[0] != u[0] || prev[1] != u[1]) {` `            ``// mark flag 1` `            ``flag = 1;` `            ``// return dfs` `            ``return``;` `        ``}` `    ``}` `}`   `// Function to count cycles formed by sticks` `function` `countCycles(N, A, M) {` `    ``// initializing adjaceny list` `    ``let adj = [... Array(N + 1)].map(` `        ``() => [... Array(2)].map(() => []));`   `    ``// Left and Right of same sticks are connected with each` `    ``// other` `    ``for` `(let i = 1; i <= N; i++) {` `        ``adj[i][0].push([ i, 1 ]);` `        ``adj[i][1].push([ i, 0 ]);` `    ``}`   `    ``// performing all M operations` `    ``for` `(let i = 0; i < M; i++) {` `        ``adj[A[i][0]][A[i][1]].push([ A[i][2], A[i][3] ]);` `        ``adj[A[i][2]][A[i][3]].push([ A[i][0], A[i][1] ]);` `    ``}`   `    ``// answer initialized with zero` `    ``let ans = 0;`   `    ``// visited array` `    ``let vis = [... Array(N + 1)].map(` `        ``() => [... Array(2)].map(() => 0));`   `    ``// calling all non visited nodes` `    ``for` `(let i = 1; i <= N; i++) {` `        ``// if i is not visited` `        ``if` `(!vis[i][0]) {` `            ``// calling dfs function` `            ``dfs([ i, 0 ], [ -1, -1 ], adj, vis);` `            ``// adding flag to answer` `            ``ans += flag;` `            ``// resetting flag to zero` `            ``flag = 0;` `        ``}` `    ``}`   `    ``// return total cycles` `    ``return` `ans;` `}`   `// Driver Code` `const N = 5;` `const A =` `    ``[ [ 3, 0, 5, 1 ], [ 5, 0, 3, 1 ], [ 4, 0, 2, 1 ] ];` `const M = 3;`   `// Function Call` `console.log(countCycles(N, A, M)); `   `const N1 = 5;` `const A1 = [];` `const M1 = 0;`   `// Function Call` `console.log(countCycles(N1, A1, M1)); `

Output

```1
0```

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

Related Articles:

My Personal Notes arrow_drop_up