字节面试算法题：用集合中的数凑小于target的最大数（Java实现，各类用例均通过）

题目描述

思路分析

（1）要凑小于target的最大数，肯定是希望这个数和target位数相同最好，不行的话再减少一位数
（2）容易想到从target的最高位开始，从集合中找一个数，能等于它当然最好，不行的话就找小于它的最大那个。因此！就是要在数组nums中找最后一个小于等于target[0]的数（target[0]为最高位数字），这很明显的二分味道
（3）如果找到的数是等于它的，则继续找第二位；如果找到的数是小于它的，那后面位的数就不用找了，直接全都取nums中的最大值即可！注意，如果发现所有位都能找到相等的，那是不行的，也就是说最后一位不能取相等数，因此为了方便，本题可直接转换为找小于等于target-1的最大数！
（4）注意可能出现前面相等，后面某一位发现找不到符合条件的了，此时就要回到上一位重新取一个更小数，如果这一位也不行，则继续往前。如果所有位都不行，则最终结果就是比target少一位的，最大数组成的数

代码实现

1、贪心+二分（迭代法）

import java.util.*;

public class Main{

    public static void main(String[] args){
        int[] nums = new int[]{7, 6, 8, 5};
        //1.最后一位不符合，返回四位数
        System.out.println("6879 --> " + getMaxNum(nums, "6879"));
        //2.所有位不符合，返回三位数
        System.out.println("5555 --> " + getMaxNum(nums, "5555"));
        //3.中间位不符合，返回四位数
        System.out.println("5698 --> " + getMaxNum(nums, "5698"));
        //4.相等
        System.out.println("5678 --> " + getMaxNum(nums, "5678"));
        //5.不存在更小的数，返回-1
        System.out.println("1 --> " + getMaxNum(nums, "1"));
    }

    //输出小于target的最大数，用nums中数字来拼凑，可以重复使用
    public static int getMaxNum(int[] nums, String digit){
        int d = Integer.parseInt(digit);
        d--;
        digit = String.valueOf(d);
        StringBuilder sb = new StringBuilder();
        //用于标记之后位是否可以直接取最大值
        boolean flag = false;
        //先对nums排序
        Arrays.sort(nums);
        //从目标数字的第一个字符开始，一个一个取
        for(int i = 0; i < digit.length(); i++){
            if(flag){
                sb.append(nums[nums.length - 1]);
                continue;
            }
            //当前位的数字
            int target = digit.charAt(i) - '0';

            //搜索nums中最后一个小于等于target的数
            int temp = search(nums, target);
            //1.当前位不存在小于等于target的数
            //2.当前位存在小于等于target的数，再具体看是等于还是小于
            if(temp == -1){
                //两种情况：
                //1.1 现在正处于第一位，则说明后面的位直接取最大值即可，当前位不取值
                //1.2 现在处于后面的位，则需要依次回溯前面位，继续往小了取
                if(i == 0){
                    flag = true;
                }else{
                    //从上一位开始，取一个更小的数
                    int index = i - 1;
                    int newTemp = -1;
                    while(newTemp == -1 && index >= 0){
                        //上一位继续取一个比之前取的数小一点的数
                        newTemp = search(nums, sb.charAt(index) - '0' - 1);
                        //由于上一位必定要换一个数填，则直接从sb中删除
                        sb.deleteCharAt(index);
                        index--;
                    }

                    //前面所有位都找不到更小的数了，则最终结果就是除了第一位，后面位全部取最大值
                    if(newTemp == -1){
                        //简化处理，i回到第一位，并触发flag，后面所有位填最大值
                        i = 0;
                        flag = true;
                        continue;
                    }

                    //此时说明回溯时某一位找到更小的值了，则此时后面所有位都应该是最大值，先把这个值加入sb
                    sb.append(newTemp);
                    //从找到更小数的这位的下一位开始，一直到i，都赋成最大值。由于之前index多减了一次，所以这里是index+2
                    for(int j = index + 2; j <= i; j++){
                        sb.append(nums[nums.length - 1]);
                    }
                    //触发flag，后面所有位填最大值
                    flag = true;
                }
            }else{
                //等于，直接加，判下一位
                if(temp == target){
                    sb.append(temp);
                }else{
                    //小于，//触发flag，后面所有位填最大值
                    sb.append(temp);
                    flag = true;
                }
            }
        }

        if(sb.length() == 0){
            return -1;
        }
        return Integer.parseInt(sb.toString());
    }
    //搜索nums中最后一个小于等于target的数，不存在返回-1
    public static int search(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int mid = left + (right - left + 1) / 2;
            if(nums[mid] <= target){
                left = mid;
            }else{
                right = mid - 1;
            }
        }

        return nums[left] <= target ? nums[left] : -1;
    }

}

2、DFS（递归法）

import java.util.*;

public class Main{

    public static void main(String[] args){
        int[] nums = new int[]{7, 6, 8, 5};
        //1.最后一位不符合，返回四位数
        System.out.println("6879 --> " + getMaxNum(nums, "6879"));
        //2.所有位不符合，返回三位数
        System.out.println("5555 --> " + getMaxNum(nums, "5555"));
        //3.中间位不符合，返回四位数
        System.out.println("5698 --> " + getMaxNum(nums, "5698"));
        //4.相等
        System.out.println("5678 --> " + getMaxNum(nums, "5678"));
        //5.不存在更小的数，返回-1
        System.out.println("1 --> " + getMaxNum(nums, "1"));
    }

    public static int getMaxNum(int[] nums, String digit){
        Arrays.sort(nums);
        int d = Integer.parseInt(digit);
        d--;
        digit = String.valueOf(d);
        StringBuilder sb = new StringBuilder();
        dfs(nums, 0, digit, sb, true);
        if(sb.length() == 0){
            return -1;
        }
        return Integer.parseInt(sb.toString());
    }

    public static int search(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int mid = left + (right - left + 1) / 2;
            if(nums[mid] <= target){
                left = mid;
            }else{
                right = mid - 1;
            }
        }

        return nums[left] <= target ? left : -1;
    }

    public static boolean dfs(int[] nums, int pos, String digit, StringBuilder sb, boolean isFirst){
        //表明找到了和digit完全相等的数，返回
        if(pos == digit.length()){
            return true;
        }

        int target = digit.charAt(pos) - '0';
        //找到nums中最后一个小于等于target的数的索引
        int loc = search(nums, target);
        //这个for循环就实现了从大往小取，也便于之后回溯取较小值
        for(int k = loc; k >= 0; k--){
            sb.append(nums[k]);
            //当前位取到相等数了，继续取下一位
            if(nums[k] == target){
                if(dfs(nums, pos + 1, digit, sb, false)){
                    return true;
                }else{
                    //回溯
                    sb.deleteCharAt(sb.length() - 1);
                }
            }else {
                //剩余位补最大值即可
                for(int j = 0; j < digit.length() - pos - 1; j++){
                    sb.append(nums[nums.length - 1]);
                }
                return true;
            }
        }
        //当前是首位，单独处理一下
        if(isFirst){
            //剩余位补最大值即可
            for(int j = 0; j < digit.length() - pos - 1; j++){
                sb.append(nums[nums.length - 1]);
            }
            return true;
        }

        //说明当前位找不到符合条件的数，需要回溯
        return false;
    }

}

3、用例输出

6879 --> 6878
5555 --> 888
5698 --> 5688
5678 --> 5677
1 --> -1