LeetCode 每日一题 321. 拼接最大数（dp或单调栈）

最新推荐文章于 2024-03-28 13:41:01 发布
最新推荐文章于 2024-03-28 13:41:01 发布
阅读量267 收藏 1
点赞数
分类专栏： 单调栈/队列 =====LeetCode===== =====思维=====
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/birdmanqin/article/details/110496028
版权

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

我的思路（超时）：力扣有的题没有数据范围，这是很烦的，但是我dp弱，记录一下吧。

dp[i][j][k]代表第一个数组的前i个数，第二个数组的前j个数拼接成k个数的序列的最大值。

转移方程:dp[i][j][k]=max{ dp[i-1][j-1][k] ,dp[i-1][j][k-1]+a[i-1] , dp[i][j-1][k-1]+b[j-1] } （PS:i-1,j-1是因为我下标从1开始。）

C++代码：用char数组存储答案。T在第87个测试点。

#define ll long long
char dp[100][200][200][200];
char s[200],ss[200];
class Solution {
public:
    vector<int> maxNumber(vector<int>& a, vector<int>& b, int k) {
        vector<int> ans;
        int n=a.size(),m=b.size();
        if(n>m) swap(a,b),swap(n,m);
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
                for(int kk=0;kk<=k;kk++)
                    dp[i][j][kk][0]='\0';
        ss[0]='\0';
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
                for(int kk=1;kk<=k;kk++){
                    if(i>0){
                        if(strcmp(dp[i-1][j][kk],dp[i][j][kk])>0)
                            strcpy(dp[i][j][kk],dp[i-1][j][kk]);
                        strcpy(s,dp[i-1][j][kk-1]);  
                        s[kk-1]=('0'+a[i-1]);
                        s[kk]='\0';
                        if(strcmp(s,dp[i][j][kk])>0)
                            strcpy(dp[i][j][kk],s);
                    } 
                    if(j>0){
                        if(strcmp(dp[i][j-1][kk],dp[i][j][kk])>0)
                            strcpy(dp[i][j][kk],dp[i][j-1][kk]);
                        strcpy(s,dp[i][j-1][kk-1]); 
                        s[kk-1]=('0'+b[j-1]);
                        s[kk]='\0';
                        if(strcmp(s,dp[i][j][kk])>0)
                            strcpy(dp[i][j][kk],s);
                    }
                    if(i>0&&j>0){
                        if(strcmp(dp[i-1][j-1][kk],dp[i][j][kk])>0)
                            strcpy(dp[i][j][kk],dp[i-1][j-1][kk]);
                    }
                    if(kk==k){
                        if(strcmp(dp[i][j][k],ss)>0)
                            strcpy(ss,dp[i][j][k]);
                    } 
                }
        for(int i=0;i<k;i++)
            ans.push_back(ss[i]-'0');
        return ans;
    }

};

Java代码：用大数存储答案。也是T在第87个测试点。

import java.math.BigInteger;
class Solution {
    public int[] maxNumber(int[] a, int[] b, int k) {
        int n=a.length,m=b.length;
    	BigInteger[][][] dp= new BigInteger[n+1][m+1][k+10];
    	BigInteger[]aa= new BigInteger[n];
     	BigInteger[]bb= new BigInteger[m];
        for(int i=0;i<n;i++)
        	aa[i]=BigInteger.valueOf(a[i]);
        for(int i=0;i<m;i++)
        	bb[i]=BigInteger.valueOf(b[i]);
    	int [] ans = new int [k];
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
                for(int kk=0;kk<=k;kk++)
                    dp[i][j][kk]=BigInteger.ZERO;
        BigInteger s=BigInteger.ZERO,ss=BigInteger.ZERO,ten = new BigInteger("10");
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
                for(int kk=1;kk<=k;kk++){
                    if(i>0){
                        dp[i][j][kk]=dp[i-1][j][kk];
                        s=dp[i-1][j][kk-1];
                        s=s.multiply(ten).add(aa[i-1]);
                        if(dp[i][j][kk].compareTo(s)<0)
                            dp[i][j][kk]=s;
                    } 
                    if(j>0){
                        if(i==0)
                            dp[i][j][kk]=dp[i][j-1][kk];
                        else if(dp[i][j][kk].compareTo(dp[i][j-1][kk])<0) 
                            dp[i][j][kk]=dp[i][j-1][kk];
                        s=dp[i][j-1][kk-1];
                        s=s.multiply(ten).add(bb[j-1]);
                        if(dp[i][j][kk].compareTo(s)<0)
                            dp[i][j][kk]=s;
                    }
                    if(i>0&&j>0 && dp[i][j][kk].compareTo(dp[i-1][j-1][kk])<0 )
                        dp[i][j][kk]=dp[i-1][j-1][kk];
                    if(kk==k && ss.compareTo(dp[i][j][k])<0 ) ss=dp[i][j][k];
                }
        String sss = ss.toString();
        for(int i=0;i<k;i++)
        	ans[i]=(sss.charAt(i)-'0');
    	return ans;
    }
}

官方题解：菜了菜了，真没想到用单调栈。解法为，从第一个数组中选x个数（长度为x的最大子序列），从第二个数组中选k-x个数（长度为k-x的最大子序列） ,然后合并成一个最大的序列，求所有可能序列的最大序列。枚举x，用单调栈求对应的最大子序列。具体求法为，维护一个有k个元素的单调递减的栈。每次要从单调栈中弹出元素时，要考虑栈里的数和剩下的数是否够k个？大于等于k个则可以弹出，否则不能弹。放入栈时，栈内的数小于k个就放；否则就不放（单调递减的栈，现在栈顶一定大于等于这个元素，除非不够k个，否则没必要放）。然后考虑合并。假设我们现在该合并第一个最大子序列的第i个数和第一个最大子序列的第j个数。如果两个数不相等，我们肯定要先放较大的那一个；如果相等，我们要看看它们后面的数（i+1,j+1），直到两个数不同或者有一个序列走到头。如果有一个序列走到头，我们要先放没走到头的那一个。比如，9,8,6,5,7和6，5如果先放走到头的就是9866557，而如果先放没走到头的就是9866575。（因为我们要考虑没走到头的序列的下一个数是否有可能更大。）

class Solution {
public:
    void print(vector<int>& a){
        for(int i=0;i<a.size();i++)
            cout<<a[i]<<",";
        cout<<endl;
    }
    vector<int> getmax(vector<int>& a,int n,int len){
        vector<int> st(len,0);
        int top=-1;
        for(int i=0;i<n;i++){
            //top+1：栈内的个数
            //n-1-i：剩下的数
            while(top!=-1 && st[top]<a[i] && top+1+n-1-i>=len )
                top--;
            if(top<len-1) st[++top]=a[i];//不够k个才放
        }
        return st;
    }
    bool cmp(vector<int>& a,int n,int i,vector<int>& b,int m,int j){
        while(i<n&&j<m){
            //不相等放较大的
            if(a[i]>b[j]) return 1;
            else if(a[i]<b[j]) return 0; 
            //相等看后面的数
            i++;
            j++; 
        }
        //有一个走到头，则放没走到头的
        return i<n;
    }
    vector<int> merge(vector<int>& a, int n,vector<int>& b, int m){
        vector<int> c(n+m,0);
        int i=0,j=0,k=0;
        while(i<n&&j<m){
            if(cmp(a,n,i,b,m,j))
                c[k++]=a[i++];
            else 
                c[k++]=b[j++];
        }                  
        while(i<n) c[k++]=a[i++];
        while(j<m) c[k++]=b[j++];
        return c;
    }
    vector<int> maxNumber(vector<int>& a, vector<int>& b, int k) {
        int n = a.size() , m = b.size();
        int nn = min(n,k),y;
        vector<int> ans(k,0);
        for(int x=0;x<=nn;x++){
            y=k-x;
            if(y<0||y>m) continue;
            vector<int> v1= getmax(a,n,x);
            vector<int> v2= getmax(b,m,y);
            vector<int> c=merge(v1,x,v2,y);
            if(c>ans) ans=c;
        }
        return ans;
    }
};

真dp思路：太菜了太菜了，两个序列分别dp，这样就不会T了，然后再按上面说的合并即可。

dp1[i][j]代表第一个数组的前i个数拼接成j个数的序列的最大值。

dp2[i][j]代表第二个数组的前i个数拼接成j个数的序列的最大值。

转移方程:dp[i][j]=max{ dp[i-1][j] ,dp[i-1][j-1]+a[i-1] } （PS:i-1,j-1是因为我下标从1开始。）

c++会T，java可以过。

import java.math.BigInteger;

public class Solution {
    public int[] maxNumber(int[] a, int[] b, int k) {
        int n=a.length,m=b.length;
    	BigInteger[][] dp1= new BigInteger[n+1][k+1];
    	BigInteger[][] dp2= new BigInteger[m+1][k+1];
    
    	BigInteger[]aa= new BigInteger[n];
     	BigInteger[]bb= new BigInteger[m];
        for(int i=0;i<n;i++)
        	aa[i]=BigInteger.valueOf(a[i]);
        for(int i=0;i<m;i++)
        	bb[i]=BigInteger.valueOf(b[i]);
        for(int i=0;i<=k;i++)
            dp1[0][i]=dp2[0][i]=BigInteger.ZERO;
        BigInteger ten = new BigInteger("10"),s=BigInteger.ZERO,ss=BigInteger.ZERO;
        for(int i=1;i<=n;i++){
            dp1[i][0]=BigInteger.ZERO;
            for(int j=1;j<=k;j++){
                dp1[i][j]=dp1[i-1][j];
                s=dp1[i-1][j-1].multiply(ten).add(aa[i-1]);
                if(dp1[i][j].compareTo(s)<0)
                	dp1[i][j]=s;
            }
        }
        for(int i=1;i<=m;i++){
            dp2[i][0]=BigInteger.ZERO;
            for(int j=1;j<=k;j++){
                dp2[i][j]=dp2[i-1][j];
                s=dp2[i-1][j-1].multiply(ten).add(bb[i-1]);
                if(dp2[i][j].compareTo(s)<0)
                	dp2[i][j]=s;              
            }
        }
        int nn = Math.min(n,k),mm;
        BigInteger temp;
        for(int i=0;i<=nn;i++){
            mm=k-i;
            if(mm<0||mm>m) continue;
            temp = merge(dp1[n][i].toString(),i,dp2[m][mm].toString(),mm);
            if(ss.compareTo(temp)<0) ss=temp;
        }
        String sss = ss.toString();
        int [] ans = new int[k]; 
        for(int i=0;i<k;i++)
        	ans[i]=(sss.charAt(i)-'0');
    	return ans;
    }
    boolean cmp(String a,int i,int n,String b,int j,int m){
        while(i<n&&j<m){
            if(a.charAt(i)>b.charAt(j)) return true;
            else if(a.charAt(i)<b.charAt(j)) return false;
            i++;
            j++;
        }
        return (i<n);
    }
    BigInteger merge(String a,int n,String b,int m){
        BigInteger c=BigInteger.ZERO;
        BigInteger ten = new BigInteger("10");
        int i=0,j=0;
        while(i<n&&j<m){
            if(cmp(a,i,n,b,j,m))
                c=c.multiply(ten).add(BigInteger.valueOf(a.charAt(i++)-'0'));
            else c=c.multiply(ten).add(BigInteger.valueOf(b.charAt(j++)-'0'));
        }
        while(i<n) c=c.multiply(ten).add(BigInteger.valueOf(a.charAt(i++)-'0'));
        while(j<m) c=c.multiply(ten).add(BigInteger.valueOf(b.charAt(j++)-'0'));
        return c;
    }
}

 

 

Qingo呀
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode 每日一题 912. 排序数组 C++描述
01-06
LeetCode 每日一题 912. 排序数组 难度 中等 给定一个整数数组 nums，将该数组升序排列。 示例 1： 输入：[5,2,3,1] 输出：[1,2,3,5] 示例 2： 输入：[5,1,1,2,0,0] 输出：[0,0,1,1,2,5] 提示： 1 <= A.length &...
leetcode每日一题总结.zip
03-24
这个“leetcode每日一题总结.zip”压缩包文件显然包含了一个作者在准备2020年秋季招聘（秋招）时对LeetCode上每日一题的解答和总结。通过这样的练习，作者最终成功签约华为，一家在全球范围内知名的科技公司，这充分...
力扣—321拼接最大数
jianghuia的博客
08-03 345
题目描述 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 说明: 请尽可能地优化你算法的时间和空间复杂度。 示例 1: 输入: nums1 = [3, 4, 6, 5] nums2 = [9, 1, 2, 5, 8, 3] k = 5 输出: [
力扣练习——28 拼接最大数
qq_43403657的博客
07-18 218
单调栈构造，合并与比较操作
我的力扣算法321-拼接最大数
一坠的博客
12-02 314
ok 看题 困难 哦豁 题目意思很简单，从两个数组里面按照在原数组顺序不变，组成一个规定长度的最大数组就可以了 但是，俺不会。 class Solution { public: vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) { vector<int> res(k, 0); int n = nums1.size(
力扣 179. 最大数
weixin_55569351的博客
10-31 3761
给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。 注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。 示例 1： 输入：nums = [10,2] 输出："210" 示例2： 输入：nums = [3,30,34,5,9] 输出："9534330" 示例 3： 输入：nums = [1] 输出："1" 示例 4： 输入：nums = [10] 输出："10" 一个数字数组拼接出最大的数，nums = [3,30,34,5,9]，显...
【算法】Create Maximum Number 创建最大数
无良剑&染的博客
03-10 342
【算法】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 <= m + n from digits of the two. The ...
MangoDowner#clear-leetcode#面试题03.05.栈排序1
07-25
面试题 03.05. 栈排序原题链接：面试题 03.05. 栈排序链表实现代码type SortedStack struct {func (this *Sort
MangoDowner#clear-leetcode#面试题03.04.化栈为队1
07-25
1、go里面没有栈这个数据结构，可以用数组模拟 2、既然是用栈模拟队列，就不能有按索引直接访问数组元素的操作，直接访问数组模拟的栈最后一个元素，也就是栈顶元素
leetcode每日一题在哪-LeetCode-Solutions:我的Leetcode.com解决方案和有用的代码
06-30
每日一题在哪编码_挑战 这是我每天回答 Leetcode 问题的地方。 下面我将为我的每个答案写一个快速解释。 这个 repo 将作为一个地方来跟踪我的问题解决能力以及我的算法交流工作。 ### 2016 年 4 月 11 日星期一 19:...
拼接最大数
最新发布
weixin_54143563的博客
03-28 445
通过栈顶指针的移动来表示某个数字是选择还是舍弃，当前遍历数字与栈顶元素比较，如果当前遍历数字更大那么就舍弃栈顶元素，那么remain就要减1，当remain为0时说明我们已经舍弃了remain个数字，即表明供我们选择的只剩下k个了不能再舍弃只能全部选择了。问题描述：有两个整数数组nums1和nums2，它们的长度分别是m和n，现在给一个整数k，需要在这两个数组中按顺序取出k个数字，最后组成一个长度为k的数组，要求最后长度为k的数组最大。对于该函数，输入一个数组和k，得到一个k个元素的按顺序最大的数组子串。
后缀数组的应用：[Leetcode] 321.拼接最大数（困难）
明朗晨光的专栏
04-16 452
1. 在一个数组中从左往右挑 m 个数，怎么挑选才能使得其尽量大；2. 从两个数组中挑选出来的数怎么合并成一个数才能最大？
C++算法：321拼接最大数
闻缺陷则喜何志丹
11-03 279
给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k
[LeetCode] Complex Number Multiplication 复数相乘
weixin_34018169的博客
04-03 100
  Given two strings representing two complex numbers. You need to return a string representing their multiplication. Note i2 = -1 according to the definition. Example 1: Input: "1+1i", "1+1i" O...
【LeetCode刷题笔记-24 321：拼接最大数】
weixin_43890220的博客
12-02 180
题目： 之前刷的题里面有相似的，比如说移掉K位数字（笔记7），下一个排列数（笔记2）。所以，今天这道题说要在两个数组中找出最大排列的时候，我第一个想到的方法就是利用栈来处理。但是思考了很久，也不知道怎么组织两个栈之间的关系，后来根据题解，才完全弄清楚。 为什么要这么做？ 我觉得我们做题，不只是要弄懂它的方法，还要尽量去想，为什么能想到这个做法。 1.首先呢，根据以往的经验，用栈来处理这种最大排列，最大子序列的问题是最方便的，因为它可以比较栈顶数字和下一个数字的大小，来选择性的入栈和出栈。 比较栈顶数字和下
leetcode321. 拼接最大数
qq_38507234的博客
08-10 95
题目：321. 拼接最大数 class Solution { public int[] maxNumber(int[] nums1, int[] nums2, int k) { int m = Math.min(k, nums1.length); // 取值范围： n <= k <= m, k表示从nums1取几个数 int n = Math.max(0, k-nums2.length); int[] res = new int[k];
OJ28 拼接最大数
Sanbai__的博客
09-20 231
给定长度分别为 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之贪心算法刷题总结3
nuist_NJUPT的博客
03-06 655
leetcode之贪心算法刷题总结3 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择，就能得到问题的答案。贪心算法需要充分挖掘题目中条件，没有固定的模式，解决有贪心算法需要一定的直觉和经验。 贪心算法不是对所有问题都能得到整体最优解。能使用贪心算法解决的问题具有「贪心选择性质」。「贪心选择性质」严格意义上需要数学证明。能使用贪心算法解决的问题必须具备「无后效性」，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。 1-煎饼排序 题目链接：题目链接戳这里！！！ 思路:这题
"LeetCode每日一题高频面试算法题目1：队列实现栈
eue.isEmpty()){  return null;  }  while(queue.size() > 1){  help.add(queue.poll());  } ... LeetCode每日一题高频面试算法题目1中的队列实现栈，为算法学习者提供了一个很好的训练机会。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值