Related Articles

# Check loop in array according to given constraints

• Difficulty Level : Medium
• Last Updated : 23 Jun, 2021

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.

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`

## C#

 `// C# program to check if``// a given array is cyclic or not``using` `System;``using` `System.Collections.Generic;``public` `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` `bool` `isCycleRec(``int` `v, List<``int``>[] adj,``                         ``List visited,``                         ``List recur)``  ``{``    ``visited[v] = ``true``;``    ``recur[v] =  ``true``;` `    ``for` `(``int` `i = 0; i < adj[v].Count; i++)``    ``{``      ``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[]``      ``else` `if` `(visited[adj[v][i]] == ``true` `&&``               ``recur[adj[v][i]] == ``true``)``        ``return` `true``;``    ``}``    ``recur[v] = ``false``;``    ``return` `false``;``  ``}` `  ``// Returns true if []arr has cycle``  ``static` `bool` `isCycle(``int``[] arr, ``int` `n)``  ``{` `    ``// Create a graph using given moves in []arr``    ``List<``int``>[] adj = ``new` `List<``int``>[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``    ``List visited = ``new` `List();``    ``for` `(``int` `i = 0; i < n; i++)``      ``visited.Add(``true``);``    ``List recur = ``new` `List();``    ``for` `(``int` `i = 0; i < n; i++)``      ``recur.Add(``true``);` `    ``for` `(``int` `i = 0; i < n; i++)``      ``if` `(visited[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``)``      ``Console.WriteLine(``"Yes"``);``    ``else``      ``Console.WriteLine(``"No"``);``  ``}``}` `// This code is contributed by aashish1995`

## Javascript

 ``

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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.