# Check loop in array according to given constraints

Given an array arr[0..n-1] of positive and negative numbers we need to find if there is a cycle in array with given rules of movements. If a number at an i index is positive, then move arr[i]%n forward steps, i.e., next index to visit is (i + arr[i])%n. Conversely, if it’s negative, move backward arr[i]%n steps i.e., next index to visit is (i – arr[i])%n. Here n is size of array. If value of arr[i]%n is zero, then it means no move from index i.

Examples:

```Input: arr[] = {2, -1, 1, 2, 2}
Output: Yes
Explanation: There is a loop in this array
because 0 moves to 2, 2 moves to 3, and 3
moves to 0.

Input  : arr[] = {1, 1, 1, 1, 1, 1}
Output : Yes
Whole array forms a loop.

Input  : arr[] = {1, 2}
Output : No
We move from 0 to index 1. From index
1, there is no move as 2%n is 0. Note that
n is 2.
```

Note that self loops are not considered a cycle. For example {0} is not cyclic.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to form a directed graph of array elements using given set of rules. While forming the graph we don’t make self loops as value arr[i]%n equals to 0 means no moves. Finally our task reduces to detecting cycle in a directed graph. For detecting cycle, we use DFS and in DFS if reach a node which is visited and recursion call stack, we say there is a cycle.

## C++

 `// C++ program to check if a given array is cyclic or not ` `#include ` `using` `namespace` `std; ` ` `  `// A simple Graph DFS based recursive function to check if ` `// there is cycle in graph with vertex v as root of DFS. ` `// Refer below article for details. ` `// https://www.geeksforgeeks.org/detect-cycle-in-a-graph/ ` `bool` `isCycleRec(``int` `v, vector<``int``>adj[], ` `               ``vector<``bool``> &visited, vector<``bool``> &recur) ` `{ ` `    ``visited[v] = ``true``; ` `    ``recur[v] = ``true``; ` `    ``for` `(``int` `i=0; iadj[n]; ` `    ``for` `(``int` `i=0; i visited(n, ``false``); ` `    ``vector<``bool``> recur(n, ``false``); ` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to check if  ` `// a given array is cyclic or not  ` `import` `java.util.Vector; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// A simple Graph DFS based recursive function ` `    ``// to check if there is cycle in graph with  ` `    ``// vertex v as root of DFS. Refer below article for details. ` `    ``// https://www.geeksforgeeks.org/detect-cycle-in-a-graph/ ` `    ``static` `boolean` `isCycleRec(``int` `v, Vector[] adj, ` `                                     ``Vector visited, ` `                                     ``Vector recur)  ` `    ``{ ` `        ``visited.set(v, ``true``); ` `        ``recur.set(v, ``true``); ` ` `  `        ``for` `(``int` `i = ``0``; i < adj[v].size(); i++)  ` `        ``{ ` `            ``if` `(visited.elementAt(adj[v].elementAt(i)) == ``false``)  ` `            ``{ ` `                ``if` `(isCycleRec(adj[v].elementAt(i),  ` `                               ``adj, visited, recur)) ` `                    ``return` `true``; ` `            ``} ` ` `  `            ``// There is a cycle if an adjacent is visited ` `            ``// and present in recursion call stack recur[] ` `            ``else` `if` `(visited.elementAt(adj[v].elementAt(i)) == ``true` `&&  ` `                       ``recur.elementAt(adj[v].elementAt(i)) == ``true``) ` `                ``return` `true``; ` `        ``} ` `        ``recur.set(v, ``false``); ` `        ``return` `false``; ` `    ``} ` ` `  `    ``// Returns true if arr[] has cycle ` `    ``@SuppressWarnings``(``"unchecked"``) ` `    ``static` `boolean` `isCycle(``int``[] arr, ``int` `n)  ` `    ``{ ` ` `  `        ``// Create a graph using given moves in arr[] ` `        ``Vector[] adj = ``new` `Vector[n]; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``if` `(i != (i + arr[i] + n) % n &&  ` `                          ``adj[i] != ``null``) ` `                ``adj[i].add((i + arr[i] + n) % n); ` ` `  `        ``// Do DFS traversal of graph to detect cycle ` `        ``Vector visited = ``new` `Vector<>(); ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``visited.add(``true``); ` `        ``Vector recur = ``new` `Vector<>(); ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``recur.add(``true``); ` ` `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``if` `(visited.elementAt(i) == ``false``) ` `                ``if` `(isCycleRec(i, adj, visited, recur)) ` `                    ``return` `true``; ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[] arr = { ``2``, -``1``, ``1``, ``2``, ``2` `}; ` `        ``int` `n = arr.length; ` `        ``if` `(isCycle(arr, n) == ``true``) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by sanjeev2552 `

## Python3

 `# Python3 program to check if a  ` `# given array is cyclic or not  ` ` `  `# A simple Graph DFS based recursive  ` `# function to check if there is cycle  ` `# in graph with vertex v as root of DFS.  ` `# Refer below article for details.  ` `# https:#www.geeksforgeeks.org/detect-cycle-in-a-graph/  ` `def` `isCycleRec(v, adj, visited, recur): ` `    ``visited[v] ``=` `True` `    ``recur[v] ``=` `True` `    ``for` `i ``in` `range``(``len``(adj[v])): ` `        ``if` `(visited[adj[v][i]] ``=``=` `False``): ` `            ``if` `(isCycleRec(adj[v][i], adj,  ` `                               ``visited, recur)):  ` `                ``return` `True` ` `  `        ``# There is a cycle if an adjacent is visited  ` `        ``# and present in recursion call stack recur[]  ` `        ``elif` `(visited[adj[v][i]] ``=``=` `True` `and`  `                ``recur[adj[v][i]] ``=``=` `True``):  ` `            ``return` `True` ` `  `    ``recur[v] ``=` `False` `    ``return` `False` ` `  `# Returns true if arr[] has cycle  ` `def` `isCycle(arr, n): ` `     `  `    ``# Create a graph using given  ` `    ``# moves in arr[]  ` `    ``adj ``=` `[[] ``for` `i ``in` `range``(n)] ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(i !``=` `(i ``+` `arr[i] ``+` `n) ``%` `n):  ` `            ``adj[i].append((i ``+` `arr[i] ``+` `n) ``%` `n)  ` ` `  `    ``# Do DFS traversal of graph  ` `    ``# to detect cycle    ` `    ``visited ``=` `[``False``] ``*` `n  ` `    ``recur ``=` `[``False``] ``*` `n ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(visited[i] ``=``=` `False``): ` `            ``if` `(isCycleRec(i, adj, ` `                           ``visited, recur)):  ` `                ``return` `True` `    ``return` `True` ` `  `# Driver code  ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``arr ``=` `[``2``, ``-``1``, ``1``, ``2``, ``2``]  ` `    ``n ``=` `len``(arr)  ` `    ``if` `(isCycle(arr, n)):  ` `        ``print``(``"Yes"``)  ` `    ``else``: ` `        ``print``(``"No"``) ` ` `  `# This code is contributed by PranchalK `

Output :

` Yes`

This article is contributed by Roshni Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

6

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.