Given a circular connected array consisting of elements from 1 to n. Starting from 1st element, you can jump from any element to any other element which is x distance apart and in the right direction, the task is to find the minimum jumps required to cover all the given elements of list m if you can choose any value of x.
Examples:
Input: n = 5, m = { 1, 2, 4 }
Output: 2
Explanation: circular array will be like this 1, 2, 3, 4, 5, 1, 2, 3, 4, ….
for x = 3, u can jump from 1 -> 4 and 4 -> 2 thus minimum jumps required will be 2.Input: n = 6, m = { 3, 4 }
Output: 3
Explanation: 1 -> 2 -> 3 -> 4
Approach: The given problem can be solved by using the Greedy Approach. Follow the steps below to solve the problem:
- Initialize an array m[] which consists of elements to cover.
- Take a variable mx to store the maximum element that needs to be covered. mx – 1 also denotes the maximum possible jumps required to cover all given elements.
- check if m.size() = 1 ?
- if yes then check if m[0] = 1 ? if yes then output “0” else output “1”.
- Run a loop from i = 1 to n, where i = size of jump
- j = 1, stores current position
- For every i: calculate the number of jumps required to cover all elements and store minimum jumps.
- Return minimum jumps.
Below is the implementation of the above approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to calculate minimum // number of jumps int Minimum_jumps( int N, int m[], int n)
{ if (n == 1) {
if (m[0] == 1)
return 0;
else
return 1;
}
// Set to store copy of elements
// of array m[]
unordered_set< int > s;
// Store maximum element that need to
// be cover also equal to maximum
// possible required jumps
int mx = 0;
for ( int i = 0; i < n; i++) {
s.insert(m[i]);
mx = max(mx, m[i]);
}
// Variable to store final ans.
int mnans = N;
// Loop from jump size 1 to N-1
for ( int i = 0; i < N; i++) {
unordered_set< int > s1 = s;
// Store no. of jumps
int ans = 0;
// Current position
int j = 1;
int z = n;
while (z > 0 && ans <= mx) {
if (j > N)
j = j % N;
// To check whether element
// j need to be cover or not
if (s1.find(j) != s1.end()) {
z--;
s1.erase(j);
}
j += i;
ans++;
}
ans--;
// Store minimum number of jumps
mnans = min(mnans, ans);
}
return mnans;
} // Driver code int main()
{ int N = 6;
// Elements to visit
int m[] = { 3, 4 };
int n = sizeof (m) / sizeof (m[0]);
// Function call
cout << Minimum_jumps(N, m, n) << endl;
return 0;
} |
// Java code to implement the approach import java.util.HashSet;
class GFG
{ // Function to calculate minimum
// number of jumps
static int Minimum_jumps( int N, int [] m, int n) {
if (n == 1 ) {
if (m[ 0 ] == 1 )
return 0 ;
else
return 1 ;
}
// Set to store copy of elements
// of array m[]
HashSet<Integer> s = new HashSet<>();
// Store maximum element that need to
// be cover also equal to maximum
// possible required jumps
int mx = 0 ;
for ( int i = 0 ; i < n; i++) {
s.add(m[i]);
mx = Math.max(mx, m[i]);
}
// Variable to store final ans.
int mnans = N;
// Loop from jump size 1 to N-1
for ( int i = 0 ; i < N; i++) {
HashSet<Integer> s1 = (HashSet<Integer>) s.clone();
// Store no. of jumps
int ans = 0 ;
// Current position
int j = 1 ;
int z = n;
while (z > 0 && ans <= mx) {
if (j > N)
j = j % N;
// To check whether element
// j need to be cover or not
if (s1.contains(j)) {
z--;
s1.remove(j);
}
j += i;
ans++;
}
ans--;
// Store minimum number of jumps
mnans = Math.min(mnans, ans);
}
return mnans;
}
// Driver code
public static void main(String[] args)
{
int N = 6 ;
// Elements to visit
int [] m = { 3 , 4 };
int n = m.length;
// Function call
System.out.println(Minimum_jumps(N, m, n));
}
} |
# Function to calculate minimum # number of jumps def Minimum_jumps(N, m, n):
if n = = 1 :
if m[ 0 ] = = 1 :
return 0
else :
return 1
# Set to store copy of elements
# of array m[]
s = set ()
# Store maximum element that need to
# be cover also equal to maximum
# possible required jumps
mx = 0
for i in range (n):
s.add(m[i])
mx = max (mx, m[i])
# Variable to store final ans.
mnans = N
# Loop from jump size 1 to N-1
for i in range (N):
s1 = set (s)
# Store no. of jumps
ans = 0
# Current position
j = 1
z = n
while z > 0 and ans < = mx:
if j > N:
j = j % N
# To check whether element
# j need to be cover or not
if j in s1:
z - = 1
s1.remove(j)
j + = i
ans + = 1
ans - = 1
# Store minimum number of jumps
mnans = min (mnans, ans)
return mnans
# Driver code N = 6
# Elements to visit m = [ 3 , 4 ]
n = len (m)
# Function call print (Minimum_jumps(N, m, n))
|
// C# code to implement the approach using System;
using System.Collections.Generic;
public class GFG{
// Function to calculate minimum
// number of jumps
static int Minimum_jumps( int N, int [] m, int n) {
if (n == 1) {
if (m[0] == 1)
return 0;
else
return 1;
}
// Set to store copy of elements
// of array m[]
HashSet< int > s = new HashSet< int >();
// Store maximum element that need to
// be cover also equal to maximum
// possible required jumps
int mx = 0;
for ( int i = 0; i < n; i++) {
s.Add(m[i]);
mx = Math.Max(mx, m[i]);
}
// Variable to store final ans.
int mnans = N;
// Loop from jump size 1 to N-1
for ( int i = 0; i < N; i++) {
HashSet< int > s1 = new HashSet< int >();
s1.UnionWith(s);
// Store no. of jumps
int ans = 0;
// Current position
int j = 1;
int z = n;
while (z > 0 && ans <= mx) {
if (j > N)
j = j % N;
// To check whether element
// j need to be cover or not
if (s1.Contains(j)) {
z--;
s1.Remove(j);
}
j += i;
ans++;
}
ans--;
// Store minimum number of jumps
mnans = Math.Min(mnans, ans);
}
return mnans;
}
// Driver code
static public void Main (){
int N = 6;
// Elements to visit
int [] m = { 3, 4 };
int n = m.Length;
// Function call
Console.Write(Minimum_jumps(N, m, n));
}
} |
// Function to calculate minimum // number of jumps function Minimum_jumps(N, m, n) {
if (n == 1) {
if (m[0] == 1) {
return 0;
} else {
return 1;
}
}
// Set to store copy of elements
// of array m[]
let s = new Set();
// Store maximum element that need to
// be cover also equal to maximum
// possible required jumps
let mx = 0;
for (let i = 0; i < n; i++) {
s.add(m[i]);
mx = Math.max(mx, m[i]);
}
// Variable to store final ans.
let mnans = N;
// Loop from jump size 1 to N-1
for (let i = 0; i < N; i++) {
let s1 = new Set(s);
// Store no. of jumps
let ans = 0;
// Current position
let j = 1;
let z = n;
while (z > 0 && ans <= mx) {
if (j > N) {
j = j % N;
}
// To check whether element
// j need to be cover or not
if (s1.has(j)) {
z -= 1;
s1. delete (j);
}
j += i;
ans += 1;
}
ans -= 1;
// Store minimum number of jumps
mnans = Math.min(mnans, ans);
}
return mnans;
} // Driver code let N = 6; // Elements to visit let m = [3, 4]; let n = m.length; // Function call console.log(Minimum_jumps(N, m, n)); |
3
Time Complexity: O(NlogN), where N = size of given circular array
Auxiliary space: O(n), where n = no. of elements need to cover