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

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:

1. If X is even, then convert X to X/2
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:

1. Define a function func which calculates the cost recursively.
2. Store all the cost of elements in an array of pairs.
3. Sort the array of pairs according to their cost.
4. 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 ` `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> 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]);` `}`   `// 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 arr = ``new` `ArrayList<>();`   `    ``for``(``int` `i = l; i <= r; i++)` `        ``arr.add(i);`   `    ``// Array to store the costs` `    ``ArrayList> 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)`

Output:

```13

```

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

 `// C++ implementation of the above approach ` `#include ` `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 > result;`   `    ``// Define DP array` `    ``int` `dp[r + 1] = {0};` `    ``dp = 1;` `    ``dp = 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` `{` `  ``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 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)`

Output:

```13

```

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 arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.