2023华为OD机试真题-组合出合法最小数(JAVA、Python、C++)

题目描述：
给一个数组，数组里面都是代表非负整数的字符串，将数组里所有的数值排列组合拼接起来组成一个数字，输出拼接成的最小的数字。
输入描述：
一个数组，数组不为空，数组里面都是代表非负整数的字符串，可以是0开头，例如：["13", "045", "09", "56"]。
数组的大小范围：[1, 50]
数组中每个元素的长度范围：[1, 30]
输出描述：
以字符串的格式输出一个数字，如果最终结果是多位数字，要优先选择输出不是“0”开头的最小数字；如果拼接出的数字都是“0”开头，则选取值最小的，并且把开头部分的“0”都去掉再输出；如果是单位数“0”，可以直接输出“0”
补充说明：
 收起
示例1
输入：
20 1
输出：
120
说明：
["20", "1"]能组成 201和120， 其中120比较小
示例2
输入：
08 10 2
输出：
10082
说明：
["08", "10", "2"]能组成 08102、 08210、10082、10208、20810、21008等数字，其中"0"开头的08102和08201排除，选择最小的10082输出
示例3
输入：
01 02
输出：
102
说明：
["01", "02"]能拼接成0102和0201，都是“0”开头，选取较小的0102，去掉前面的0，输出102
 

import java.util.*;
 
public class Main {
    static List<String> result = new ArrayList<>();
    static LinkedList<String> path = new LinkedList<>();
    static boolean[] used = null;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        String[] strArr = line.split(" ");
 
        used = new boolean[strArr.length];
        Arrays.fill(used, false);
        dfs(strArr, 0);
 
        Collections.sort(result);
        String target = null;
        int i = -1;
        int len = result.get(0).length();
        while (target == null) {
            if (i == len - 1) {
                //System.out.println(0);
                break;
            }
            i++;
            for (String s : result) {
                if (s.charAt(i) != '0') {
                    target = s;
                    break;
                }
            }
        }
        if (target == null) {
            System.out.println(0);
        } else {
            System.out.println(delZero(target));
        }
    }
    public static void dfs(String[] strArr, int depth) {
        if (depth == strArr.length) {
            //save
            String res = getPathString(path);
            result.add(res);
            return;
        }
        for (int i = 0; i < strArr.length; i++) {
            if (used[i])
                continue;
            path.add(strArr[i]);
            used[i] = true;
            dfs(strArr, depth + 1);
            used[i] = false;
            path.removeLast();
        }
    }
    public static String getPathString(LinkedList<String> path) {
        StringBuilder sb = new StringBuilder();
        for (String str : path) {
            sb.append(str);
        }
        return sb.toString();
    }
    public static String delZero(String target) {
        char[] chars = target.toCharArray();
        int pos = 0;
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] != '0') {
                break;
            } else {
                pos++;
            }
        }
        return target.substring(pos);
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
bool StrCampare(std::string str1,std::string str2)//字符串排序
{
    string str12 = str1+str2;
    string str21 = str2+str1;
    return str12<str21;
}
int main()
{
    vector<string> vecInput;
    string strInput;
    while(cin>>strInput)//输入
    {
        vecInput.push_back(strInput);
    }
    sort(vecInput.begin(),vecInput.end(),StrCampare);
    //特殊处理，当第一个字符串首字母第第一个字符为0时，需要与后续调换，如果全部都是0开头，则不调换
    if(vecInput.size() == 0)
    {
        return 0;
    }
   if(vecInput[0][0] == '0')
    {
        int nSize = vecInput.size();
        for(int nIndex =1;nIndex<nSize;nIndex++)
        {
            if(vecInput[nIndex][0] != '0')//存在不以0开头的字符串 a
            {
                std::string strMini = vecInput[nIndex];
                for(int nChange = nIndex;nChange>0;nChange--)//将a放在第一位，第0个到第nIndedx-1的向后移动
                {
                    vecInput[nChange] = vecInput[nChange-1];
                }
                vecInput[0] = strMini;
                break;
            }
        }
    }
    std::string strRes;
    for(auto iter:vecInput)
    {
        strRes += iter;
    }
    //对结果进行处理 删除strRes字符串前面的0
    int nPos = 0;
    for(int nIndex=0;nIndex<strRes.size();nIndex++)
    {
         if(strRes[nIndex]!='0')
        {
            nPos = nIndex;
            break;
        }
    }
    strRes = strRes.substr(nPos);
    cout<<strRes;
    return 0;
}