# Find the count of unvisited indices in an infinite array

• Difficulty Level : Medium
• Last Updated : 05 Dec, 2019

Given an array of infinite length and two integers M and N which are co-primes, the task is to find the number of positions that cannot be visited starting from the first position when in a single move from arr[i], either arr[i + M] or arr[i + N] can be reached. Note that the result is always finite.

Examples:

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: M = 2, N = 5
Output: 2
From index 0, the indices that can be visited are
0 + 2 = 2
0 + 2 + 2 = 4
0 + 5 = 5
0 + 2 + 2 + 2 = 6
0 + 2 + 5 = 7
0 + 2 + 2 + 2 + 2 = 8
0 + 2 + 2 + 5 = 9
0 + 5 + 5 = 10

1 and 3 are the only indices that cannot be visited.

Input: M = 5, N = 6
Output: 15

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

Approach:

• Find the largest index that can’t be obtained using any combination of M & N using Frobenius number say X = (M * N) – M – N .
• Since, X is the largest index than cannot be visited so every index greater than it doesn’t need to be checked.
• Now, for the indices smaller than X, if X is unvisited then Y = X – M and Z = X – N are also unrechable and same goes Y – M and Z – N and so on.. until the indices are greater than 0.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ``#include ``using` `namespace` `std;`` ` `// Function to return the count ``// of unvisited indices starting ``// from the index 0 ``int` `countUnvisited(``int` `n, ``int` `m)``{``     ` `    ``// Largest index that ``    ``// cannot be visited ``    ``int` `X = (m * n) - m - n; `` ` `    ``// Push the index to the queue ``    ``queue<``int``> queue;`` ` `    ``queue.push(X); `` ` `    ``// To store the required count ``    ``int` `count = 0; ``    ``while` `(queue.size() > 0) ``    ``{ `` ` `        ``// Current index that cannot be visited ``        ``int` `curr = queue.front(); ``        ``queue.pop();`` ` `        ``// Increment the count for ``        ``// the current index ``        ``count++; `` ` `        ``// (curr - m) and (curr - n) are also ``        ``// unreachable if they are valid indices ``        ``if` `(curr - m > 0) ``            ``queue.push(curr - m); ``        ``if` `(curr - n > 0) ``            ``queue.push(curr - n); ``    ``} `` ` `    ``// Return the required count ``    ``return` `count; ``}`` ` `// Driver code ``int` `main()``{``    ``int` `n = 2, m = 5; `` ` `    ``cout << countUnvisited(n, m);`` ` `    ``return` `0;``}`` ` `// This code is contributed by Sanjit_Prasad`

## Java

 `// Java implementation of the approach``import` `java.util.LinkedList;``import` `java.util.Queue;`` ` `class` `GFG {`` ` `    ``// Function to return the count``    ``// of unvisited indices starting``    ``// from the index 0``    ``public` `static` `int` `countUnvisited(``int` `n, ``int` `m)``    ``{`` ` `        ``// Largest index that``        ``// cannot be visited``        ``int` `X = (m * n) - m - n;`` ` `        ``// Push the index to the queue``        ``Queue queue = ``new` `LinkedList<>();``        ``queue.add(X);`` ` `        ``// To store the required count``        ``int` `count = ``0``;``        ``while` `(!queue.isEmpty()) {`` ` `            ``// Current index that cannot be visited``            ``int` `curr = queue.poll();`` ` `            ``// Increment the count for``            ``// the current index``            ``count++;`` ` `            ``// (curr - m) and (curr - n) are also``            ``// unreachable if they are valid indices``            ``if` `(curr - m > ``0``)``                ``queue.add(curr - m);``            ``if` `(curr - n > ``0``)``                ``queue.add(curr - n);``        ``}`` ` `        ``// Return the required count``        ``return` `count;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``2``, m = ``5``;``        ``System.out.print(countUnvisited(n, m));``    ``}``}`

## Python 3

 `# Python 3 implementation of the approach `` ` `# Function to return the count ``# of unvisited indices starting ``# from the index 0 ``def` `countUnvisited(n, m):``     ` `    ``# Largest index that ``    ``# cannot be visited ``    ``i ``=` `0``    ``X ``=` `(m ``*` `n) ``-` `m ``-` `n`` ` `    ``# Push the index to the queue ``    ``queue ``=` `[]`` ` `    ``queue.append(X)`` ` `    ``# To store the required count ``    ``count ``=` `0``    ``while` `(``len``(queue) > ``0``):``         ` `        ``# Current index that cannot be visited ``        ``curr ``=` `queue[``0``] ``        ``queue.remove(queue[``0``])`` ` `        ``# Increment the count for ``        ``# the current index ``        ``count ``+``=` `1`` ` `        ``# (curr - m) and (curr - n) are also ``        ``# unreachable if they are valid indices ``        ``if` `(curr ``-` `m > ``0``):``            ``queue.append(curr ``-` `m) ``        ``if` `(curr ``-` `n > ``0``):``            ``queue.append(curr ``-` `n) `` ` `    ``# Return the required count ``    ``return` `count`` ` `# Driver code ``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `2``    ``m ``=` `5`` ` `    ``print``(countUnvisited(n, m))``     ` `# This code is contributed by Surendra_Gangwar`

## C#

 `// C# implementation of the above approach ``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG ``{`` ` `    ``// Function to return the count``    ``// of unvisited indices starting``    ``// from the index 0``    ``public` `static` `int` `countUnvisited(``int` `n, ``int` `m)``    ``{`` ` `        ``// Largest index that``        ``// cannot be visited``        ``int` `X = (m * n) - m - n;`` ` `        ``// Push the index to the queue``        ``Queue<``int``> queue = ``new` `Queue<``int``>();``        ``queue.Enqueue(X);`` ` `        ``// To store the required count``        ``int` `count = 0;``        ``while` `(queue.Count != 0) ``        ``{`` ` `            ``// Current index that cannot be visited``            ``int` `curr = queue.Dequeue();`` ` `            ``// Increment the count for``            ``// the current index``            ``count++;`` ` `            ``// (curr - m) and (curr - n) are also``            ``// unreachable if they are valid indices``            ``if` `(curr - m > 0)``                ``queue.Enqueue(curr - m);``            ``if` `(curr - n > 0)``                ``queue.Enqueue(curr - n);``        ``}`` ` `        ``// Return the required count``        ``return` `count;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``int` `n = 2, m = 5;``        ``Console.WriteLine(countUnvisited(n, m));``    ``}``}`` ` `// This code is contributed by PrinciRaj1992`
Output:
```2
```

My Personal Notes arrow_drop_up