 GeeksforGeeks App
Open App Browser
Continue

# Minimum jumps to cover given elements from circular sequence of 1 to n

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

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `// Function to calculate minimum``// number of jumps``int` `Minimum_jumps(``int` `N, ``int` `m[], ``int` `n)``{` `    ``if` `(n == 1) {` `        ``if` `(m == 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);` `    ``// Function call``    ``cout << Minimum_jumps(N, m, n) << endl;``    ``return` `0;``}`

## Java

 `// 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 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 s1 = (HashSet) 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));``  ``}``}`

## Python3

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

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

## Javascript

 `// Function to calculate minimum``// number of jumps``function` `Minimum_jumps(N, m, n) {` `  ``if` `(n == 1) {``    ``if` `(m == 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));`

Output

`3`

Time Complexity: O(NlogN), where N = size of given circular array
Auxiliary space: O(n), where n = no. of elements need to cover

My Personal Notes arrow_drop_up