GeeksforGeeks App
Open App
Browser
Continue

# Find the count of unvisited indices in an infinite array

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

Input: M = 2, N = 5
Output:
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 Practice

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 unreachable 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`

## Javascript

 ``

Output:

`2`

Time Complexity: O(n * m)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up