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: 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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach 
#include <bits/stdc++.h>
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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> 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));
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

2

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

Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.