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 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++ 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 |
// 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));
}
} |
# 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# 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 |
<script> // JavaScript implementation of the approach // Function to return the count // of unvisited indices starting // from the index 0 function countUnvisited(n, m)
{ // Largest index that
// cannot be visited
let X = (m * n) - m - n;
// Push the index to the queue
let queue = [];
queue.push(X);
// To store the required count
let count = 0;
while (queue.length > 0)
{
// Current index that cannot be visited
let curr = queue[0];
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 let n = 2, m = 5; document.write(countUnvisited(n, m)); // This code is contributed by shinjanpatra </script> |
2
Time Complexity: O(n * m)
Auxiliary Space: O(1)