LeetCode321. 拼接最大数

最新推荐文章于 2024-07-08 22:58:13 发布
最新推荐文章于 2024-07-08 22:58:13 发布
阅读量1.1k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 笔记 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_33321609/article/details/94403782
本文深入探讨了如何从两个数字数组中选取k个数字组成最大可能的数值，详细解析了算法设计思路，包括如何保持原数组顺序的同时选择最优数字组合，并提供了具体的实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。

求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。

说明: 请尽可能地优化你算法的时间和空间复杂度。

示例 1:

输入:
nums1 = [3, 4, 6, 5]
nums2 = [9, 1, 2, 5, 8, 3]
k = 5
输出:
[9, 8, 6, 5, 3]
示例 2:

输入:
nums1 = [6, 7]
nums2 = [6, 0, 4]
k = 5
输出:
[6, 7, 6, 0, 4]
示例 3:

输入:
nums1 = [3, 9]
nums2 = [8, 9]
k = 3
输出:
[9, 8, 9]

链接：https://leetcode-cn.com/problems/create-maximum-number

看到这道题，原以为很简单，依次选，选大的就好啊，但是当两边一样大的时候，就纠结了，然后用了一个方法，超时。有用了一个方法，内存超了。
最后突然有了灵感，如果选500个数，那就可能0+500,1+499,2+498…
而这时候只要考虑两个小算法就行，第一个就是在数组内找到指定长度的最大值。第二个就是拼接两个值成最大值
答案：

public int[] maxNumber(int[] nums1, int[] nums2, int k) {
    int[] ans = null;
    for (int i = 0; i <= k; i++) {
        if (i == 1) {
            System.out.println();
        }
        if (nums2.length < k - i || i > nums1.length) {
            continue;
        }
        int[] ans1 = getF(nums1, i);
        int[] ans2 = getF(nums2, k - i);
        int[] anss = getFF(ans1, ans2);
        if (ans == null || lager(anss, ans)) {
            ans = anss;
        }
    }
    return ans;
}

//拼接两个数组
private int[] getFF(int[] ans1, int[] ans2) {
    int[] ans = new int[ans1.length + ans2.length];
    int key = 0;
    for (int i = 0, j = 0; i < ans1.length || j < ans2.length; ) {
        if (j == ans2.length) {
            ans[key++] = ans1[i++];
        } else if (i == ans1.length) {
            ans[key++] = ans2[j++];
        } else {
            if (lager(ans1, ans2, i, j)) {
                ans[key++] = ans1[i++];
            } else {
                ans[key++] = ans2[j++];
            }
        }
    }
    return ans;
}

//nums1数组中最大的num位值
private int[] getF(int[] nums1, int num) {
    int[] ans = new int[num];
    if (num == 0) {
        return ans;
    }
    int key = -1;
    for (int i = 0; i < nums1.length; i++) {
        if (key + 1 + nums1.length - i == num) {
            ans[++key] = nums1[i];
            continue;
        }
        if (key == -1 || nums1[i] <= ans[key]) {
            if (key == num - 1) {
                continue;
            }
            ans[++key] = nums1[i];
        } else {
            key--;
            i--;
        }
    }
    return ans;
}

private boolean lager(int[] an1, int[] an2) {
    for (int i = 0; i < an1.length; i++) {
        if (an1[i] > an2[i]) {
            return true;
        } else if (an1[i] < an2[i]) {
            return false;
        }
    }
    return false;
}

private boolean lager(int[] an1, int[] an2, int sta1, int sta2) {
    int i = 0;
    for (; i + sta1 < an1.length && i + sta2 < an2.length; i++) {
        if (an1[i + sta1] > an2[i + sta2]) {
            return true;
        } else if (an1[i + sta1] < an2[i + sta2]) {
            return false;
        }
    }
    if (i + sta2 == an2.length) {
        return true;
    }
    return false;
}

附加：
超时算法：

class Solution {
    

    int[] ans;

    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        ans = new int[k];
        maxNum(nums1, 0, nums2, 0, 0, k, false);
        return ans;
    }

    private void maxNum(int[] nums1, int sta1, int[] nums2, int sta2, int key, int k, boolean canH) {
        if (key == k) {
            return;
        }
        if (canH) {
            ans[key] = 0;
        }
        int temp1 = ans[key] - 1;
        int st1 = -1;
        for (int i = sta1; i < nums1.length && i <= (nums1.length + nums2.length) - (sta2 + (k - key)); i++) {
            if (nums1[i] > temp1) {
                temp1 = nums1[i];
                st1 = i;
            }
        }
        int st2 = -1;
        int temp2 = ans[key] - 1;
        for (int i = sta2; i < nums2.length && i <= (nums1.length + nums2.length) - (sta1 + (k - key)); i++) {
            if (nums2[i] > temp2) {
                temp2 = nums2[i];
                st2 = i;
            }
        }
        if (temp1 > temp2) {
            if (temp1 < ans[key]) {
            } else if (temp1 == ans[key]) {
                maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k, false | canH);
            } else {
                ans[key] = temp1;
                maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k, true);
            }
            return;
        }
        if (temp1 < temp2) {
            if (temp2 < ans[key]) {
            } else if (temp2 == ans[key]) {
                maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k, false | canH);
            } else {
                ans[key] = temp2;
                maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k, true);
            }
            return;
        }
        if (temp1 < ans[key]) {
        } else if (temp1 == ans[key]) {
            maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k, false | canH);
        } else {
            ans[key] = temp1;
            maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k, true);
        }
        canH = false;

        if (temp2 < ans[key]) {
        } else if (temp2 == ans[key]) {
            maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k, false | canH);
        } else {
            ans[key] = temp2;
            maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k, true);
        }
    }
}

超内存算法：

class Solution {
    

    int[] ans;

    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        bbb = new boolean[nums1.length + 1][nums2.length + 1];
        anss = new int[nums1.length + 1][nums2.length + 1][k];
        ans = new int[k];
        ans = maxNum(nums1, 0, nums2, 0, 0, k);
        return ans;
    }

    boolean[][] bbb;
    int[][][] anss;

    private int[] maxNum(int[] nums1, int sta1, int[] nums2, int sta2, int key, int k) {
        if (key == k) {
            return new int[0];
        }
        if (bbb[sta1][sta2]) {
            return anss[sta1][sta2];
        }
        bbb[sta1][sta2] = true;
        int temp1 = -1;
        int st1 = -1;
        for (int i = sta1; i < nums1.length && i <= (nums1.length + nums2.length) - (sta2 + (k - key)); i++) {
            if (nums1[i] > temp1) {
                temp1 = nums1[i];
                st1 = i;
            }
        }
        int st2 = -1;
        int temp2 = -1;
        for (int i = sta2; i < nums2.length && i <= (nums1.length + nums2.length) - (sta1 + (k - key)); i++) {
            if (nums2[i] > temp2) {
                temp2 = nums2[i];
                st2 = i;
            }
        }
        if (temp1 > temp2) {
            int[] an = maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k);
            int[] ann = new int[an.length + 1];
            ann[0] = temp1;
            for (int i = 0; i < an.length; i++) {
                ann[i + 1] = an[i];
            }
            anss[sta1][sta2] = ann;
            return ann;
        }
        if (temp1 < temp2) {
            int[] an = maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k);
            int[] ann = new int[an.length + 1];
            ann[0] = temp2;
            for (int i = 0; i < an.length; i++) {
                ann[i + 1] = an[i];
            }
            anss[sta1][sta2] = ann;
            return ann;
        }
        int[] an1 = maxNum(nums1, st1 + 1, nums2, sta2, key + 1, k);
        int[] an2 = maxNum(nums1, sta1, nums2, st2 + 1, key + 1, k);
        if (lager(an1, an2)) {
            int[] ann = new int[an1.length + 1];
            ann[0] = temp1;
            for (int i = 0; i < an1.length; i++) {
                ann[i + 1] = an1[i];
            }
            anss[sta1][sta2] = ann;
            return ann;
        } else {
            int[] ann = new int[an2.length + 1];
            ann[0] = temp1;
            for (int i = 0; i < an2.length; i++) {
                ann[i + 1] = an2[i];
            }
            anss[sta1][sta2] = ann;
            return ann;
        }
    }

    private boolean lager(int[] an1, int[] an2) {
        for (int i =0; i < an1.length; i++) {
            if (an1[i] > an2[i]) {
                return true;
            } else if (an1[i] < an2[i]) {
                return false;
            }
        }
        return false;
    }
}
把数组中的数拼接起来,求最大值(最小值)
zckongbai的博客
02-24 8416
问题分析 最暴力的解法就是把所有的组合都找出来, 然后排序得到最大值(或者最小值),这样还搞什么算法,直接抛弃. 这个问题的思路为: 在一个数组中依次选出最合适的值放在结果中. 那么问题就变成了如何选出最合适的值, 下面以求最大值为例说明: 对于两个数比较, 首先要考虑的就是位数的差异, 比如 9和 10 从值的大小比较, 那应该是10胜出, 但是 109 肯定没有 910大. 所以比较的时候要把
【LeetCode】321. 拼接最大数
最新发布
步子哥的博客
12-07 1112
在每一步中都要考虑后续可能的最大值保持原数组的相对顺序正确处理边界情况。
321. 拼接最大数
Umbrella Corporation
04-26 9171
给定长度分别为m和n的两个数组，其元素由0-9构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n)个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为k的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例1: 输入: nums1 = ...
LeetCode 321. 拼接最大数
Hydralisk2333的博客
06-05 254
LeetCode 321. 拼接最大数问题描述解决思路 问题描述 解决思路 我们可以用一句话来描述我们的解决思路，即“在两个数组中分别找出长度为a和b的最大递减子序列，a和b的和为k，之后将两个最大递减子序列合并”。 要实现我们这个思路，需要实现以下几个模块的代码： 从数组中找出固定长度的最大递减子序列 合并两个子序列 可以比较两个子序列的大小 从数组中找出固定长度的最大递减子序列 vector<int> getSubMaxSeq(vector<int>& nu
LeetCode 321.拼接最大数
dayslrk的博客
03-09 144
class Solution { public: vector<int> GetMonStack(vector<int> &nums,int length){ stack<int> s; int n=nums.size(); int drop_num=n-length; for(int i=0;i<n;++i){ while(!s.empty() &&.
leetcode 321. 拼接最大数
Qin_酱的博客
07-21 626
321. 拼接最大数 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例 1: 输入: nums1 = [3, 4, 6, 5] nums2 = [9, 1, 2, 5, 8, 3] k = 5 输出:
Java实现 LeetCode 321 拼接最大数
热门推荐
南 墙
03-06 1万+
321. 拼接最大数 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例 1: 输入: nu...
贪心算法------LeetCode 321拼接最大数
qq_33854211的博客
05-02 765
Leetcode 321.拼接最大数题目描述分析输入数据的运行步骤如何选取最大子序列如何对数组进行归并形成新数主函数 题目描述 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 来源：力扣（LeetCode） 链接：https://leetcode-cn
LeetCode第321题拼接最大数
qq_41967623的博客
12-02 575
321. 拼接最大数 题目： 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例 1: 输入: nums1 = [3, 4, 6, 5] nums2 = [9, 1, 2, 5, 8, 3] k = 5
Leetcode 295.数据流的中位数
Mr_Richard的博客
07-08 987
任意多个连续的斜杠（即，设置辅助栈，栈中元素为长度为2的数组，分别存当前插入的val值和它插入后栈中的最小val值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。回溯暴力解，给回溯函数设置返回值，当找到一个可行解时，停止计算，返回结果。取出最小元素：从栈顶元素获取当前栈中的最小val值；操作，并能在常数时间内检索到最小元素的栈。开头），请你将其转化为更加简洁的规范路径。没想到字符串切片，纯指针实现切片，代码臃肿。对于此问题，任何其他格式的点（例如，在 Unix 风格的文件系统中，一个点（
LeetCode 321 拼接最大数 HERODING的LeetCode之路
HERODING23的博客
12-02 223
给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例 1: 输入: nums1 = [3, 4, 6, 5] nums2 = [9, 1, 2, 5, 8, 3] k = 5 输出: [9, 8, 6, 5
LeetCode第 321 题：拼接最大数(C++)
zj
08-09 1425
321. 拼接最大数 - 力扣（LeetCode） 贪心算法，每次都尽可能地从可选范围内选择最大的数字。因为要保持元素的相对顺序，可选范围即为使得剩下的元素个数加上已选的元素依然有 k 个。 但是这题难在两个数组中有重复元素，比如示例 3 里面，两个数组里面都有元素 9 ，到底应该选择哪个 9 呢？只能根据后面的元素进行判断，这时可以写一个递归函数，将后面的元素作为新的数组进行选择，但是如果重复元素很多，递归栈就会很深。 那么换个思路，我们一共需要选择 k 个数，假设把这 k 个数分为两份，一份来自nums
leetcode : 321. Create Maximum Number : 有点难度的贪心法
smileyk的专栏
03-28 833
321. Create Maximum Number My Submissions Question Total Accepted: 4587 Total Submissions: 22666 Difficulty: Hard Given two arrays of length m and n with digits 0-9 representing
[LeetCode]321. 拼接最大数
weixin_39947473的博客
05-12 1207
参考：原博地址 mergeVector非常巧妙！！ 321. 拼接最大数 class Solution { public: vector<int> maxVector(vector<int> nums,int x){ vector<int> tip; tip.clear(); int drop=nums.s...
leetcode 拼接最大数
weixin_42496727的博客
11-04 361
题目链接 思路：单调栈 这个题目其实就是好几个问题绑在了一起，现在我们来一层层拆开它。 首先，要挑选出k个，那么可以从第一个数组里面挑选0个、1个、2个、…k个，对应的，从第二个数组里面挑选 k个、k-1、k-2、…0个，那么挑选这些元素有什么规则，题目是要求他们拼凑出来的数组最大，那么他们自身出来的肯定就要最大。 问题1.在nums数组中，挑选k个数，并且要保证相对顺序，如何使得挑选出来的数字组成的数组最大。 思路：单调栈 定义一个栈，这个栈从栈底到栈顶，依次减小，即栈顶永远是栈内最小的。，然后去掉的元素
[LeetCode][H0321]拼接最大数（Java）（分治）
凉月的博客
03-14 535
题目描述： 给定长度分别为m和n的两个数组，其元素由0-9构成，表示两个自然数各位上的数字。现在从这两个数组中选出k (k <= m + n)个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为k的数组。 说明:请尽可能地优化你算法的时间和空间复杂度。 示例1: 输入: n...
【LeetCode】321. 拼接最大数 结题报告 (C++)
暮雨凉初透
02-09 1220
原题地址：https://leetcode-cn.com/problems/create-maximum-number/submissions/ 题目描述： 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k &lt;= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求...
LeetCode 321. Create Maximum Number（寻找最大数）
James Pan
04-25 2020
原题网址：https://leetcode.com/problems/create-maximum-number/ Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k  from digits of th
leetcode 321. Create Maximum Number 根据两个整数创造一个有k位的最大的数 + 贪心算法
JackZhangNJU的专栏
10-02 1146
Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k Example 1: nums1 = [3, 4, 6, 5] nums2 = [9, 1, 2, 5, 8, 3] k = 5 return [9, 8,
Java面试技巧：LeetCode最大数题解解析
4. 最大数问题：在本题中，通常要求编写一个函数，该函数接受一个整数数组作为输入，并返回一个字符串，该字符串是由输入数组中的数字按照某种排序后组成的最大数。这涉及到对整数进行字符串化、自定义排序算法和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值