C++ 是否有任何有效的方法可以从两个数组的交替元素中获得尽可能长的排序数组？

例如： N=5，M=4

A=[4,2,10,5,9]

B=[4,5,6,15]

所以排序最长的数组是[2,4,5,6,9,15]

这是我的方法，但我想知道是否有任何有效的方法可用。我可以保证它不是来自任何在线编码竞赛，它是在采访中被问到我的，所以我想知道有效的方法，如果有的话

#include<bits/stdc++.h> 
using namespace std; 
int mx=0;
void generateUtil(int A[], int B[], int C[], int i, int j, int m, int n, 
                int len, bool flag) 
{ 
    if (flag) 
    { 
        if (len) 
            mx=max(mx,len+1); 
        for (int k = i; k < m; k++) 
        { 
            if (!len) 
            { 
                C[len] = A[k];
                generateUtil(A, B, C, k+1, j, m, n, len, !flag); 
            } 
            { 
                if (A[k] > C[len]) 
                { 
                    C[len+1] = A[k]; 
                    generateUtil(A, B, C, k+1, j, m, n, len+1, !flag); 
                } 
            } 
        } 
    } 
    { 
        for (int l = j; l < n; l++) 
        { 
            if (B[l] > C[len]) 
            { 
                C[len+1] = B[l]; 
                generateUtil(A, B, C, i, l+1, m, n, len+1, !flag); 
            } 
        } 
    } 
} 
void generate(int A[], int B[], int m, int n) 
{ 
    int C[m+n];
    generateUtil(A, B, C, 0, 0, m, n, 0, true); 
} 
int main() 
{ 
    int n,m,i,j;
    cin>>n>>m;
    int A[n],B[m];
    for(i=0;i<n;i++)
    {
     cin>>A[i];
    }
    for(j=0;j<n;j++)
    {
     cin>>B[j];
    }
    generate(A, B, n, m); 
    cout<<mx<<"\n";
    return 0; 
} 

#包括
使用名称空间std；
int mx=0；
void generateUtil（int A[]，int B[]，int C[]，int i，int j，int m，int n，
内部透镜，布尔标志）
{ 
国际单项体育联合会（旗）
{ 
如果（len）
mx=最大值（mx，len+1）；
对于（int k=i；kC[len]）
{ 
C[len+1]=A[k]；
generateUtil（A、B、C、k+1、j、m、n、len+1、！标志）；
} 
} 
} 
} 
{ 
对于（int l=j；lC[len]）
{ 
C[len+1]=B[l]；
generateUtil（A、B、C、i、l+1、m、n、len+1、！标志）；
} 
} 
} 
} 
void生成（int A[]，int B[]，int m，int n）
{ 
int C[m+n]；
generateUtil（A，B，C，0，0，m，n，0，true）；
} 
int main（）
{ 
int n，m，i，j；
cin>>n>>m；
int A[n]，B[m]；
对于（i=0；i>A[i]；
}
对于（j=0；j>B[j]；
}
生成（A，B，n，m）；
cout取决于您所说的高效。如果我们测量代码长度、易理解性和bug的可能性，这是非常有效的：

#include <algorithm>
#include <iterator>
#include <set>

std::set<int> result;
std::copy(std::begin(A), std::end(A), std::inserter(result, result.end()));
std::copy(std::begin(B), std::end(B), std::inserter(result, result.end()));

for (int e : result) { std::cout << e << ' '; }

#包括

编辑：看起来这实际上并不能满足要求。虽然目前我还不知道要求什么。
以下使用标准算法库。至于这是否是你的雇主想要的，这是一个悬而未决的问题

#包括
#包括
#包括
int main（）
{
int A[]={4,2,10,5,9}；
int B[]={4,5,6,15}；
std:：sort（std:：begin（A），std:：end（A））；
std:：sort（std:：begin（B），std:：end（B））；
intc[std:：size（A）+std:：size（B）]；
std:：merge（std:：begin（A）、std:：end（A）、std:：begin（B）、std:：end（B）、C）；
//std:：unique将在最后一个有效元素之后返回一个
自动iter=std:：unique（std:：begin（C），std:：end（C））；
对于（自动p=std:：begin（C）；p！=iter；++p）{
std：：在时间和空间复杂度方面效率不高，因为我的代码正在寻找所有的组合，这将创建TLE或MLE以获得更高的约束。@Anonymous很抱歉，但我不知道什么是TLE和MRE。还要注意，时间和空间效率通常是对立的，所以哪一个最重要？@Anonymous实际上，我的代码可能是不符合您的要求。我将更新我的答案，并对您的原始问题添加一些注释。@AVH我认为@Anonymous希望指出
时间限制超过
和
内存限制超过
；这意味着程序无法在时间和内存限制内分别运行。如果时间和空间是一个问题，@Anonymous应该在问题陈述中为这些约束（时间和空间）设置一个限制。这与我下面的代码[2 4 5 6 9 10 15]在给定的输入数据上给出的结果相同。总的来说，我比我更喜欢这段代码。因此，很高兴将其作为最佳答案。你需要严格的排序吗？例如，
[4 4…]
接受？您能更详细地解释一下这个算法的输出应该是什么吗？2、5和15是如何在解决方案中结束的？请阅读：我认为最简单的方法是将所有项目添加到一个集合中，然后打印集合的内容。这样做是因为集合不允许重复，并且它会自动对集合的内容进行排序NaveTest.@我读的方式，所有数组中的数字都被用来制作一组排序的唯一值。如果你对代码进行排序> < < /> > >代码> b>代码>，那么你将打破顺序。我认为问题需要保持数据的原始顺序。注意这不是有效的C++（这两个问题都不是代码）。。无法在堆栈上动态创建数组（即可变长度数组）@ Avh，这是有效的C++，据我所知，A和B的元素数量在编译时是已知的，因此C元素的计算也是编译时间的计算。事实上，如果不是这样的话，C的定义就不被允许了。“有没有什么有效的方法可以从两个数组的交替元素中获得尽可能长的排序数组？”再清楚不过了。@QuatCoder啊，你的代码中A&B的大小是constexpr这一点很好。我掩盖了这一点，我的错误！