题目描述
思路分析
（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
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
