范围 [L, R] 中的数字具有通过给定操作将第 K 个最小转换成本转换为 1

给定三个整数L , R和K其中[L, R]表示元素的范围，任务是在范围[L, R] 中找到需要 K ^th最小转换成本为1的元素。如果两个或多个元素具有相同的成本，则打印其中的最小值。

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

例子：

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

朴素方法：最简单的方法是使用递归计算与L和R之间的每个元素相关的成本。以下是步骤：

1. 定义一个函数func来递归计算成本。
2. 将元素的所有成本存储在成对数组中。
3. 根据成本对数组进行排序。
4. 然后从数组中返回第 (K-1)^个索引处的元素。

下面是上述方法的实现：

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 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][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 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)

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 arr = new List();
 
    for(int i = l; i <= r; i++)
        arr.Add(i);
 
    // Array to store the costs
    Dictionary result = new Dictionary();
    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

Javascript

 
// JavaScript implementation of
// the above approach
 
//Function to calculate the cost
function func(n)
{
    var 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
function findKthElement( l, r, k)
{
    var arr = [];
 
    for(var i = l; i <= r; i++)
        arr.push(i);
 
    // Array to store the costs
    var result = [];
 
    arr.forEach(i => {
         
        result.push([i, func(i)]);
    });
 
    // Sort the array based on cost
    result.sort();
 
    document.write( result[k - 1][0]);
}
 
// Driver Code
// Given range and6 K
var l = 12;
var r = 15;
var k = 2;
 
// Function call
findKthElement(l, r, k);
 
 

输出：

13

时间复杂度： O(2 ^N )
辅助空间： O(1)

高效方法：上述方法可以通过使用动态规划进行优化。以下是步骤：

• 为了避免重新计算重叠的子问题，初始化一个dp[]数组来存储每个遇到的子问题达到 1 的最小成本。
• 更新 dp[] 表的循环关系是：

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

• 将所有计算的成本存储在一对数组中
• 根据成本对数组进行排序。
• 然后从数组中返回第(K – 1)^个索引处的元素。

下面是上述方法的实现：

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] = 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
{
  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

蟒蛇3

# 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

输出：

13

时间复杂度： O(N*M)
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live