给定数组中 K 个数的串联的最大可能数

给定一个由N个整数组成的数组arr[]和一个正整数K ，任务是从数组arr[]中选择K个整数，使得它们的串联形成最大可能的整数。所有数组元素必须至少选择一次以创建数字。

注意：始终保证N大于或等于K 。

例子：

Input: arr[] = {3, 2, 7}, K = 3
Output: 732
Explanation:
Since each array element has to be used at least once, the biggest possible number is 732.

Input: arr[] = {1, 10, 100}, K = 4
Output: 110100100

方法：上述问题可以通过将数字排序转换为字符串来解决。最佳方法是一次取所有数字。之后，取数字最多的数字。在平局的情况下，取字典序上最大的数字。使用 to_string()函数转换字符串中的所有数字。请按照以下步骤解决问题：

• 初始化一个空字符串res来存储答案。
• 按升序对数组numbers[]进行排序。
• 初始化字符串向量v[] 。
• 使用变量i遍历范围[0, K)并将字符串数字numbers[i]推入向量v[] 。
• 将N的值减少K并将值numbers[K-1] N次推入向量v[] 。
• 使用比较器函数对向量v[]进行排序。
• 使用变量i迭代范围[v.size()-1, 0]并将值v[i]添加到变量res 。
• 执行上述步骤后，打印res的值作为答案。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Custom comparator function
bool str_cmp(string s1, string s2)
{
    return (s1 + s2 < s2 + s1);
}
 
// Function to get the largest possible
// string
string largestNumber(vector arr,
                     int K)
{
    int N = arr.size();
 
    // Initialize a new variable which
    // will store the answers.
    string res = "";
 
    // Sort the numbers array in
    // non-decreasing order
    sort(arr.begin(), arr.end());
 
    // Stores the array element which will
    // be used to construct the answer
    vector v;
 
    // Take all numbers atleast once
    for (int i = 0; i < N; i++) {
        v.push_back(to_string(arr[i]));
    }
    K -= N;
 
    // Take the largest digits number
    // for remaining required numbers
    while (K) {
        v.push_back(to_string(arr[N - 1]));
        K--;
    }
 
    // Sort the final answer according to
    // the comparator function.
    sort(v.begin(), v.end(), str_cmp);
    for (int i = v.size() - 1; i >= 0; i--)
        res += v[i];
 
    return res;
}
 
// Driver Code
int main()
{
    vector arr = { 1, 10, 100 };
    int K = 4;
    cout << largestNumber(arr, K);
 
    return 0;
}

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Custom comparator function
 
  // Function to get the largest possible
  // String
  static String largestNumber(int[] arr, int K)
  {
    int N = arr.Length;
 
    // Initialize a new variable which
    // will store the answers.
    String res = "";
 
    // Sort the numbers array in
    // non-decreasing order
    Array.Sort(arr);
 
    // Stores the array element which will
    // be used to conthe answer
    List v = new List();
 
    // Take all numbers atleast once
    for (int i = 0; i < N; i++) {
      v.Add(String.Join("",arr[i]));
    }
    K -= N;
 
    // Take the largest digits number
    // for remaining required numbers
    while (K > 0) {
      v.Add(String.Join("",arr[N - 1]));
      K--;
    }
 
    // Sort the readonly answer according to
    // the comparator function.
    v.Sort((s1,s2) => (s1 + s2).CompareTo(s2 + s1));
    for (int i = v.Count - 1; i >= 0; i--)
      res += v[i];
 
    return res;
  }
 
  // Driver Code
  public static void Main(String[] args) {
    int[] arr = { 1, 10, 100 };
    int K = 4;
    Console.Write(largestNumber(arr, K));
 
  }
}
 
// This code is contributed by Rajput-Ji

Javascript

      // JavaScript Program to implement
      // the above approach
 
      // Function to get the largest possible
      // string
      function largestNumber(arr,
          K) {
          let N = arr.length;
 
          // Initialize a new variable which
          // will store the answers.
          let res = "";
          // Sort the numbers array in
          // non-decreasing order
          arr.sort(function (a, b) { return a - b })
 
          // Stores the array element which will
          // be used to construct the answer
          let v = [];
 
          // Take all numbers atleast once
          for (let i = 0; i < N; i++) {
              v.push(arr[i].toString());
          }
          K -= N;
 
          // Take the largest digits number
          // for remaining required numbers
          while (K) {
              v.push(arr[N - 1].toString());
              K--;
          }
 
          // Sort the final answer according to
          // the comparator function.
          v.sort(function (s1, s2) { return parseInt(s1 + s2) - parseInt(s2 + s1) });
          for (let i = v.length - 1; i >= 0; i--)
              res += v[i];
 
          return res;
      }
 
      // Driver Code
 
      let arr = [1, 10, 100];
      let K = 4;
      document.write(largestNumber(arr, K));
 
 
     // This code is contributed by Potta Lokesh
 
  

输出：

110100100

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