給定一組非負整數 nums，重新排列每個數的順序（每個數不可拆分）使之組成一個最大的整數。

https://leetcode-cn.com/problems/largest-number/

注意：輸出結果可能非常大，所以你需要返回一個字符串而不是整數。

示例1：

輸入：nums = [10,2]
輸出："210"

示例2：

輸入：nums = [3,30,34,5,9]
輸出："9534330"

示例3：

輸入：nums = [1]
輸出："1"

示例4：

輸入：nums = [10]
輸出："10"

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 109

Java解法

思路：

• 最大數即最大的數字在前方排列
• 每次挑選第一位數最大即可，優先個位數，若有相同多位數字對第二位做同樣操作
• 傻逼了，34 比 3 要優先選擇參考官方解

package sj.shimmer.algorithm.m4_2021;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;

/**
 * Created by SJ on 2021/4/15.
 */

class D78 {
    public static void main(String[] args) {
        System.out.println(largestNumber(new int[]{10,2}));
        System.out.println(largestNumber(new int[]{3,30,34,5,9}));
    }
    public static String largestNumber(int[] nums) {
        int n = nums.length;
        // 轉換成包裝類型，以便傳入 Comparator 對象（此處為 lambda 表達式）
        Integer[] numsArr = new Integer[n];
        for (int i = 0; i < n; i++) {
            numsArr[i] = nums[i];
        }

        Arrays.sort(numsArr, (x, y) -> {
            long sx = 10, sy = 10;
            while (sx <= x) {
                sx *= 10;
            }
            while (sy <= y) {
                sy *= 10;
            }
            return (int) (-sy * x - y + sx * y + x);
        });

        if (numsArr[0] == 0) {
            return "0";
        }
        StringBuilder ret = new StringBuilder();
        for (int num : numsArr) {
            ret.append(num);
        }
        return ret.toString();
    }
    public static String largestNumber2(int[] nums) {
        if (nums == null||nums.length==0) {
            return "";
        }
        StringBuilder builder = new StringBuilder();
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        for (int num : nums) {
            int temp = num;
            while (temp/10>0) {
                temp= temp/10;
            }
            int key = temp % 10;
            List<Integer> list = map.getOrDefault(key, new ArrayList<>());
            list.add(num);
            map.put(key, list);
        }
        for (int i = 9; i >= 0; i--) {
            List<Integer> list = map.get(i);
            if (list != null&&list.size()>0) {
                int[] array = list.stream().mapToInt(Integer::valueOf).toArray();
                Arrays.sort(array);
                int digts = 0;
                Stack<Integer> stack = new Stack<>();
                for (int j = 0; j < array.length; j++) {
                    if (array[j]>digts*10&&array[j]<(digts+1)*10) {
                        stack.add(array[j]);
                    }else {
                        while (!stack.isEmpty()) {
                            builder.append(stack.pop());
                        }
                        stack.add(array[j]);
                        digts++;
                    }
                }
                while (!stack.isEmpty()) {
                    builder.append(stack.pop());
                }
            }
        }
        return builder.toString();
    }
    
}

image

官方解

https://leetcode-cn.com/problems/largest-number/solution/zui-da-shu-by-leetcode-solution-sid5/

1. 排序

   比較兩個數不同的拼接順序的結果，進而決定它們在結果中的排列順序 ，我思考的太復雜了

   • 時間復雜度：O(nlognlogm)

   • 空間復雜度：O(logn)