Number from a range [L, R] having Kth minimum cost of conversion to 1 by given operations

Last Updated : 14 Dec, 2020

Given three integers L, R and K where [L, R] denotes the range of elements, the task is to find the element in the range [L, R] requiring K^th minimum cost of conversion to 1. If two or more elements have the same cost, then print the minimum among them.

Cost of conversion of an element X to 1 using the given operations is the count of operations used:

If X is even, then convert X to X/2

If X is odd, then convert X to 3*X + 1

Examples:

Input: L = 12, R = 15, K = 2
Output: 13
Explanation:
The cost associated with 12 is 9 (12 –> 6 –> 3 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1)
The cost associated with 13 is 9 (13 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1)
The cost associated with 14 is 17 (14 –> 7 –> 22 –> 11 –> 34 –> 17 –> 52 –> 26 –> 13 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1)
The cost associated with 15 is 17 (15 –> 46–> 23 –> 70 –> 35 –> 106 –> 53 –> 160 –> 80 –> 40 –> 20 –> 10 –> 5 –> 16 –> 8 –> 4 –> 2 –> 1)
The element sorted according to cost is [12, 13, 14, 15].
For K = 2, the output is 13.

Input: L = 1, R = 1, K = 1
Output: 1

Naive Approach: The simplest approach is to calculate the cost associated with each element between L and R using recursion. Below are the steps:

Define a function func which calculates the cost recursively.
Store all the cost of elements in an array of pairs.
Sort the array of pairs according to their cost.
Then return the element at (K-1)^th index from the array.

Below is the implementation of the above approach:

C++14

// C++14 implementation of
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
//Function to calculate the cost
int func(int n)
{
    int count = 0;
 
    // Base case
    if (n == 2 or n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
void findKthElement(int l, int r, int k)
{
    vector<int> arr;
 
    for(int i = l; i <= r; i++)
        arr.push_back(i);
 
    // Array to store the costs
    vector<vector<int>> result;
 
    for(int i : arr)
        result.push_back({i, func(i)});
 
    // Sort the array based on cost
    sort(result.begin(), result.end());
 
    cout << (result[k - 1][0]);
}
 
// Driver Code
int main()
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k);
     
    return 0;
}
 
// This code is contributed by mohit kumar 29

Java

// Java implementation of 
// the above approach 
import java.util.*;
 
class GFG{
 
// Function to calculate the cost
static int func(int n)
{
    int count = 0;
 
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
static void findKthElement(int l, int r, int k)
{
    ArrayList<Integer> arr = new ArrayList<>();
 
    for(int i = l; i <= r; i++)
        arr.add(i);
 
    // Array to store the costs
    ArrayList<List<Integer>> result = new ArrayList<>();
 
    for(int i : arr)
        result.add(Arrays.asList(i, func(i)));
 
    // Sort the array based on cost
    Collections.sort(result, (s1, s2) -> s1.get(1) - 
                                         s2.get(1));
 
    System.out.println(result.get(k - 1).get(0));
}
 
// Driver code
public static void main (String[] args) 
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k); 
}
}
 
// This code is contributed by offbeat

Python3

# Python3 implementation of 
# the above approach
 
# Function to calculate the cost
def func(n): 
    count = 0
     
    # Base case
    if n == 2 or n == 1: 
        return 1
     
    # Even condtion
    if n % 2 == 0:   
        count = 1 + func(n//2) 
 
    # Odd condtion
    if n % 2 != 0:  
        count = 1 + func(n * 3 + 1)
 
    # Return cost  
    return count
 
# Function to find Kth element
def findKthElement(l, r, k):
    arr = list(range(l, r + 1))
 
    # Array to store the costs
    result = [] 
    for i in arr:
        result.append([i, func(i)])
 
    # Sort the array based on cost
    result.sort() 
    print(result[k-1][0])
 
# Driver Code
 
# Given range and K
l = 12
r = 15
k = 2
 
# Function Call
findKthElement(l, r, k)

C#

// C# implementation of 
// the above approach 
using System;
using System.Linq;
using System.Collections.Generic;
 
class GFG{
 
// Function to calculate the cost
static int func(int n)
{
    int count = 0;
     
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2);
 
    // Odd condtion
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1);
 
    // Return cost
    return count;
}
 
// Function to find Kth element
static void findKthElement(int l, int r, int k)
{
    List<int> arr = new List<int>();
 
    for(int i = l; i <= r; i++)
        arr.Add(i);
 
    // Array to store the costs
    Dictionary<int,
               int> result = new Dictionary<int,
                                            int>();
    foreach(int i in arr)
    {
        result.Add(i, func(i));
    }
     
    // Sort the array based on cost
    var myList = result.ToList();
     
    myList.Sort((pair1, pair2) => pair1.Value.CompareTo(
        pair2.Value));
 
    Console.WriteLine(myList[1].Key);
}
 
// Driver code
public static void Main(String[] args) 
{
     
    // Given range and6 K
    int l = 12;
    int r = 15;
    int k = 2;
     
    // Function call
    findKthElement(l, r, k); 
}
}
 
// This code is contributed by aashish1995

Output:

Time Complexity: O(2^N)
Auxiliary Space: O(1)

Efficient approach: The above approach can be optimized by using Dynamic Programming. Below are the steps:

To avoid recalculating the overlapping subproblems, initialize a dp[] array to store the minimum cost to reach 1 from for every encountered subproblem.
The recurrence relation to update the dp[] table is :

dp[n] = 1 + func(n / 2) for even elements
dp[n] = 1 + func(3 * n + 1) for odd elements

Store all the calculated costs in an array of pairs
Sort the array of pairs according to their cost.
Then return the element at (K – 1)^th index from the array.

Below is the implementation of the above approach:

C++

// C++ implementation of the above approach 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the cost
int func(int n, int dp[])
{
    int count = 0;
 
    // Base case
    if (n == 2 || n == 1)
        return 1;
 
    if (dp[n] != -1)
        return dp[n];
 
    // Even condtion
    if (n % 2 == 0)
        count = 1 + func(n / 2, dp);
 
    // Odd condition
    if (n % 2 != 0)
        count = 1 + func(n * 3 + 1, dp);
 
    // Store the result
    dp[n] = count;
    return dp[n];
}
 
// Function to find Kth element
void findKthElement(int l, int r, int k)
{
 
    // Array to store the results
    vector<pair<int, int> > result;
 
    // Define DP array
    int dp[r + 1] = {0};
    dp[1] = 1;
    dp[2] = 1;
 
    for(int i = l; i <= r; i++)
        result.push_back({i, func(i, dp)});
 
    // Sort the array based on cost
    sort(result.begin(), result.end());
     
    cout << (result[k - 1].first);
}
 
// Driver code 
int main()
{
     
    // Given range and K
    int l = 12;
    int r = 15;
    int k = 2;
 
    // Function call
    findKthElement(l, r, k);
}
 
// This code is contributed by grand_master

Java

// Java implementation of 
// the above approach 
import java.util.*;
class GFG{
     
static class Pair implements Comparable<Pair>
{
  int start,end;
   
  Pair(int s, int e)
  {
    start = s;
    end = e;
  }
 
  public int compareTo(Pair p)
  {
    return this.start - p.start;
  }
}
 
// Function to calculate 
// the cost
static int func(int n,
                int dp[])
{
  int count = 0;
 
  // Base case
  if (n == 2 || 
      n == 1)
    return 1;
 
  if (dp[n] != -1)
    return dp[n];
 
  // Even condtion
  if (n % 2 == 0)
    count = 1 + func(n / 2, dp);
 
  // Odd condition
  if (n % 2 != 0)
    count = 1 + func(n * 3 + 
                     1, dp);
 
  // Store the result
  dp[n] = count;
  return dp[n];
}
 
// Function to find Kth element
static void findKthElement(int l, 
                           int r, 
                           int k)
{
  // Array to store the 
  // results
  Vector<Pair> result = 
         new Vector<>();
 
  // Define DP array
  int []dp = new int[r + 1];
  dp[1] = 1;
  dp[2] = 1;
 
  for(int i = l; i <= r; i++)
    result.add(new Pair(i, 
               func(i, dp)));
 
  // Sort the array based 
  // on cost
  Collections.sort(result);
 
  System.out.print(
  result.get(k - 1).start);
}
 
// Driver code 
public static void main(String[] args)
{    
  // Given range and K
  int l = 12;
  int r = 15;
  int k = 2;
 
  // Function call
  findKthElement(l, r, k);
}
}
 
// This code is contributed by gauravrajput1

Python3

# Python3 implementation of the above approach
# Function to calculate the cost
def func(n, dp): 
    count = 0
 
    # Base case
    if n == 2 or n == 1: 
        return 1
    if n in dp:
      return dp[n]  
 
    # Even condtion
    if n % 2 == 0:  
        count = 1 + func(n//2, dp)
 
    # Odd condition
    if n % 2 != 0:   
        count = 1 + func(n * 3 + 1, dp) 
 
    # Store the result
    dp[n]= count 
    return dp[n] 
 
# Function to find Kth element
def findKthElement(l, r, k):
    arr = list(range(l, r + 1))
 
    # Array to store the results
    result = [] 
 
    # Define DP array
    dp ={1:1, 2:1} 
 
    for i in arr:
        result.append([i, func(i, dp)])
 
    # Sort the array based on cost
    result.sort() 
    print(result[k-1][0])
 
# Given range and K
l = 12
r = 15
k = 2
 
# Function Call
findKthElement(l, r, k)

C#

// C# implementation of 
// the above approach 
using System;
using System.Collections;
 
class GFG{
     
class Pair
{
   public int start,end;
    
  public Pair(int s, int e)
  {
    start = s;
    end = e;
  }
}
 
class sortHelper : IComparer
{
   int IComparer.Compare(object a, object b)
   {
      Pair first=(Pair)a;
      Pair second=(Pair)b;
         
      return first.start - second.start;
   }
} 
      
  
// Function to calculate 
// the cost
static int func(int n, int []dp)
{
  int count = 0;
  
  // Base case
  if (n == 2 || n == 1)
    return 1;
  
  if (dp[n] != -1)
    return dp[n];
  
  // Even condtion
  if (n % 2 == 0)
    count = 1 + func(n / 2, dp);
  
  // Odd condition
  if (n % 2 != 0)
    count = 1 + func(n * 3 + 
                     1, dp);
  
  // Store the result
  dp[n] = count;
  return dp[n];
}
  
// Function to find Kth element
static void findKthElement(int l, 
                           int r, 
                           int k)
{
  // Array to store the 
  // results
  ArrayList result = 
         new ArrayList();
  
  // Define DP array
  int []dp = new int[r + 1];
  dp[1] = 1;
  dp[2] = 1;
  
  for(int i = l; i <= r; i++)
    result.Add(new Pair(i, 
               func(i, dp)));
  
  // Sort the array based 
  // on cost
  result.Sort(new sortHelper());
  
  Console.Write(((Pair)result[k - 1]).start);
}
  
// Driver code 
public static void Main(string[] args)
{    
  // Given range and K
  int l = 12;
  int r = 15;
  int k = 2;
  
  // Function call
  findKthElement(l, r, k);
}
}
 
// This code is contributed by rutvik_56

Output:

Time Complexity: O(N*M)
Auxiliary Space: O(N)

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

Related Articles

C++14

Java

Python3

C#

C++

Java

Python3

C#