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

Last Updated : 10 Mar, 2023

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

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

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

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[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));
  }
}

Javascript

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

Output

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

Suggest improvement

Minimum array elements to be changed to make Recaman's sequence

Share your thoughts in the comments

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

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?