Number from a range [L, R] having Kth minimum cost of conversion to 1 by given operations
Last Updated :
03 May, 2023
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 Kth 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
#include <bits/stdc++.h>
using namespace std;
int func( int n)
{
int count = 0;
if (n == 2 or n == 1)
return 1;
if (n % 2 == 0)
count = 1 + func(n / 2);
if (n % 2 != 0)
count = 1 + func(n * 3 + 1);
return count;
}
void findKthElement( int l, int r, int k)
{
vector< int > arr;
for ( int i = l; i <= r; i++)
arr.push_back(i);
vector<vector< int >> result;
for ( int i : arr)
result.push_back({i, func(i)});
sort(result.begin(), result.end());
cout << (result[k - 1][0]);
}
int main()
{
int l = 12;
int r = 15;
int k = 2;
findKthElement(l, r, k);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int func( int n)
{
int count = 0 ;
if (n == 2 || n == 1 )
return 1 ;
if (n % 2 == 0 )
count = 1 + func(n / 2 );
if (n % 2 != 0 )
count = 1 + func(n * 3 + 1 );
return count;
}
static void findKthElement( int l, int r, int k)
{
ArrayList<Integer> arr = new ArrayList<>();
for ( int i = l; i <= r; i++)
arr.add(i);
ArrayList<List<Integer>> result = new ArrayList<>();
for ( int i : arr)
result.add(Arrays.asList(i, func(i)));
Collections.sort(result, (s1, s2) -> s1.get( 1 ) -
s2.get( 1 ));
System.out.println(result.get(k - 1 ).get( 0 ));
}
public static void main (String[] args)
{
int l = 12 ;
int r = 15 ;
int k = 2 ;
findKthElement(l, r, k);
}
}
|
Python3
def func(n):
count = 0
if n = = 2 or n = = 1 :
return 1
if n % 2 = = 0 :
count = 1 + func(n / / 2 )
if n % 2 ! = 0 :
count = 1 + func(n * 3 + 1 )
return count
def findKthElement(l, r, k):
arr = list ( range (l, r + 1 ))
result = []
for i in arr:
result.append([i, func(i)])
result.sort()
print (result[k - 1 ][ 0 ])
l = 12
r = 15
k = 2
findKthElement(l, r, k)
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
class GFG{
static int func( int n)
{
int count = 0;
if (n == 2 || n == 1)
return 1;
if (n % 2 == 0)
count = 1 + func(n / 2);
if (n % 2 != 0)
count = 1 + func(n * 3 + 1);
return count;
}
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);
Dictionary< int ,
int > result = new Dictionary< int ,
int >();
foreach ( int i in arr)
{
result.Add(i, func(i));
}
var myList = result.ToList();
myList.Sort((pair1, pair2) => pair1.Value.CompareTo(
pair2.Value));
Console.WriteLine(myList[1].Key);
}
public static void Main(String[] args)
{
int l = 12;
int r = 15;
int k = 2;
findKthElement(l, r, k);
}
}
|
Javascript
<script>
function func(n)
{
var count = 0;
if (n == 2 || n == 1)
return 1;
if (n % 2 == 0)
count = 1 + func(n / 2);
if (n % 2 != 0)
count = 1 + func(n * 3 + 1);
return count;
}
function findKthElement( l, r, k)
{
var arr = [];
for ( var i = l; i <= r; i++)
arr.push(i);
var result = [];
arr.forEach(i => {
result.push([i, func(i)]);
});
result.sort();
document.write( result[k - 1][0]);
}
var l = 12;
var r = 15;
var k = 2;
findKthElement(l, r, k);
</script>
|
Time Complexity: O(2N)
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++
#include <bits/stdc++.h>
using namespace std;
int func( int n, int dp[])
{
int count = 0;
if (n == 2 || n == 1)
return 1;
if (dp[n] != -1)
return dp[n];
if (n % 2 == 0)
count = 1 + func(n / 2, dp);
if (n % 2 != 0)
count = 1 + func(n * 3 + 1, dp);
dp[n] = count;
return dp[n];
}
void findKthElement( int l, int r, int k)
{
vector<pair< int , int > > result;
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(result.begin(), result.end());
cout << (result[k - 1].first);
}
int main()
{
int l = 12;
int r = 15;
int k = 2;
findKthElement(l, r, k);
}
|
Java
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;
}
}
static int func( int n,
int dp[])
{
int count = 0 ;
if (n == 2 ||
n == 1 )
return 1 ;
if (dp[n] != - 1 )
return dp[n];
if (n % 2 == 0 )
count = 1 + func(n / 2 , dp);
if (n % 2 != 0 )
count = 1 + func(n * 3 +
1 , dp);
dp[n] = count;
return dp[n];
}
static void findKthElement( int l,
int r,
int k)
{
Vector<Pair> result =
new Vector<>();
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)));
Collections.sort(result);
System.out.print(
result.get(k - 1 ).start);
}
public static void main(String[] args)
{
int l = 12 ;
int r = 15 ;
int k = 2 ;
findKthElement(l, r, k);
}
}
|
Python3
def func(n, dp):
count = 0
if n = = 2 or n = = 1 :
return 1
if n in dp:
return dp[n]
if n % 2 = = 0 :
count = 1 + func(n / / 2 , dp)
if n % 2 ! = 0 :
count = 1 + func(n * 3 + 1 , dp)
dp[n] = count
return dp[n]
def findKthElement(l, r, k):
arr = list ( range (l, r + 1 ))
result = []
dp = { 1 : 1 , 2 : 1 }
for i in arr:
result.append([i, func(i, dp)])
result.sort()
print (result[k - 1 ][ 0 ])
l = 12
r = 15
k = 2
findKthElement(l, r, k)
|
C#
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;
}
}
static int func( int n, int []dp)
{
int count = 0;
if (n == 2 || n == 1)
return 1;
if (dp[n] != -1)
return dp[n];
if (n % 2 == 0)
count = 1 + func(n / 2, dp);
if (n % 2 != 0)
count = 1 + func(n * 3 +
1, dp);
dp[n] = count;
return dp[n];
}
static void findKthElement( int l,
int r,
int k)
{
ArrayList result =
new ArrayList();
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)));
result.Sort( new sortHelper());
Console.Write(((Pair)result[k - 1]).start);
}
public static void Main( string [] args)
{
int l = 12;
int r = 15;
int k = 2;
findKthElement(l, r, k);
}
}
|
Javascript
<script>
function func(n,dp)
{
let count = 0;
if (n == 2 ||
n == 1)
return 1;
if (dp[n] != -1)
return dp[n];
if (n % 2 == 0)
count = 1 + func(Math.floor(n / 2), dp);
if (n % 2 != 0)
count = 1 + func(n * 3 +
1, dp);
dp[n] = count;
return dp[n];
}
function findKthElement(l,r,k)
{
let result = [];
let dp = new Array(r + 1);
dp[1] = 1;
dp[2] = 1;
for (let i = l; i <= r; i++)
result.push([i,
func(i, dp)]);
result.sort( function (a,b){ return a[0]-b[0];});
document.write(
result[k-1][0]);
}
let l = 12;
let r = 15;
let k = 2;
findKthElement(l, r, k);
</script>
|
Time Complexity: O(N*M)
Auxiliary Space: O(N)
Efficient approach: Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Create a vector DP to store the solution of the subproblems and initialize it with 0.
- Initialize the dp with base cases and compute for even and odd conditions.
- Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP.
- Return the final solution.
Implementation :
C++
#include <bits/stdc++.h>
using namespace std;
void func( int n, vector< int >& dp)
{
dp[1] = 1;
dp[2] = 1;
for ( int i = 3; i <= n; i++) {
if (i % 2 == 0)
dp[i] = 1 + dp[i / 2];
else
dp[i] = 1 + dp[i * 3 + 1];
}
}
void findKthElement( int l, int r, int k)
{
vector< int > dp(r + 1, 0);
func(r, dp);
vector<pair< int , int > > result;
for ( int i = l; i <= r; i++)
result.push_back({i, dp[i]});
sort(result.begin(), result.end());
cout << result[k - 1].first;
}
int main()
{
int l = 12;
int r = 15;
int k = 2;
findKthElement(l, r, k);
}
|
Java
import java.util.*;
class GFG {
static int [] func( int n) {
int [] dp = new int [n + 1 ];
dp[ 1 ] = 1 ;
for ( int i = 2 ; i <= n; i++) {
dp[i] = 1 + dp[i - 1 ];
if (i % 2 == 0 ) {
dp[i] = Math.min(dp[i], 1 + dp[i / 2 ]);
}
else {
dp[i] = Math.min(dp[i], 2 + dp[(i + 1 ) / 2 ]);
}
}
return dp;
}
public static void main(String[] args) {
int l = 12 ;
int r = 15 ;
int k = 2 ;
int [] dp = func(r);
List< int []> lst = new ArrayList<>();
for ( int i = l; i <= r; i++) {
lst.add( new int []{i, dp[i]});
}
lst.sort(Comparator.comparingInt(a -> a[ 1 ]));
System.out.println(lst.get(k - 1 )[ 0 ]);
}
}
|
Python3
def func(n):
dp = [ 0 ] * (n + 1 )
dp[ 1 ] = 1
for i in range ( 2 , n + 1 ):
dp[i] = 1 + dp[i - 1 ]
if i % 2 = = 0 :
dp[i] = min (dp[i], 1 + dp[i / / 2 ])
else :
dp[i] = min (dp[i], 2 + dp[(i + 1 ) / / 2 ])
return dp
if __name__ = = '__main__' :
l, r, k = 12 , 15 , 2
dp = func(r)
lst = [(i, dp[i]) for i in range (l, r + 1 )]
lst.sort(key = lambda x: x[ 1 ])
print (lst[k - 1 ][ 0 ])
|
Javascript
function func(n) {
let dp = Array(n+1).fill(0);
dp[1] = 1;
for (let i = 2; i <= n; i++) {
dp[i] = 1 + dp[i-1];
if (i % 2 === 0) {
dp[i] = Math.min(dp[i], 1 + dp[i/2]);
}
else {
dp[i] = Math.min(dp[i], 2 + dp[(i+1)/2]);
}
}
return dp;
}
let l = 12, r = 15, k = 2;
let dp = func(r);
let lst = Array.from({length: r-l+1}, (_, i) => [i+l, dp[i+l]]);
lst.sort((a, b) => a[1] - b[1]);
console.log(lst[k-1][0]);
|
C#
using System;
using System.Collections.Generic;
class Program {
static int [] Func( int n) {
int [] dp = new int [n + 1];
dp[1] = 1;
for ( int i = 2; i <= n; i++) {
dp[i] = 1 + dp[i - 1];
if (i % 2 == 0) {
dp[i] = Math.Min(dp[i], 1 + dp[i / 2]);
}
else {
dp[i] = Math.Min(dp[i], 2 + dp[(i + 1) / 2]);
}
}
return dp;
}
static void FindKthElement( int l, int r, int k) {
int [] dp = Func(r);
List<( int , int )> lst = new List<( int , int )>();
for ( int i = l; i <= r; i++) {
lst.Add((i, dp[i]));
}
lst.Sort((x, y) => x.Item2.CompareTo(y.Item2));
Console.WriteLine(lst[k - 1].Item1);
}
static void Main( string [] args) {
int l = 12;
int r = 15;
int k = 2;
FindKthElement(l, r, k);
}
}
|
Output
13
Time Complexity: O(r log r), The time complexity of the findKthElement function is O(r log r)
Auxiliary Space: O(r), since it creates a DP array of size r+1
Share your thoughts in the comments
Please Login to comment...