Question

我最近在一次采访中遇到了这个问题。我真的无法想出答案。我开始，从第一个数组中获取第一个元素，然后在另一个数组中找到比这个元素多的元素。但是，我的意思是，我不知道，无法真正形成解决方案。问题如下：

给定两个已排序的数组A和B，生成所有可能的数组，使得第一个元素从A获取，然后从B获取，然后从A获取，依此类推，直到数组耗尽为止。生成的数组应以B中的元素结束。

Eg:
A = {10, 15, 25}
B = {1, 5, 20, 30}

The resulting arrays are:
  10 20
  10 20 25 30
  10 30
  15 20
  15 20 25 30
  15 30
  25 30

我不是在寻找代码，只需一个algo / pseduo-code就行了。谢谢！

Answer 1

@dpmcmlxxvi建议的BFS解决方案很有意思。另外，我建议使用递归变体。一些基本要点：

递归函数的一个输入参数应该是一个布尔变量，它将指示是否应该从A或B添加元素;您将在后续的递归调用中替换此值
数组已排序 - 使用该信息！当你看到排序数组时，总是想到二进制搜索 - 在这种情况下，你应该递归传递最后添加的元素，然后在另一个数组中，二元搜索第一个元素大于最后一个元素
如果最后添加的元素来自B，则将当前工作数组添加到结果列表中

Answer 2

如何使用带有BFS路径搜索的有向图。

创建一个directed graph，其中如果B中的元素更大，则从数组A中的元素创建有向边到数组B中的每个元素。反之亦然。如果A中的元素更大，则从数组B中的元素到数组A中的每个元素创建有向边。
从A
然后使用BFS搜索生成所有可能的路径。
每次路径包含来自B的元素时，将该子路径添加到路径的解决方案列表
当A的所有元素都被用作搜索键时停止

<强>更新

根据@MiljenMikic的建议，您可以通过加快步骤1来利用数组排序这一事实。您不必搜索另一个数组中的所有元素以查找大于元素。只需跟踪最后找到的内容，然后在搜索时将指针向前移动。

Answer 3

基于简单java的递归解决方案可以像这样

public static void main(String[] args) {

    int[] A = {10, 15, 25};
    int[] B = {1, 5, 20, 30};

    Stack<Integer> st = new Stack<>();

    for (int i = 0; i < A.length; i++) {
        st.push(A[i]);
        generateArrays(A, B, i, 0, st, false);
        st.clear();
    }
}

static void generateArrays(int ar1[], int ar2[], int index_of_a, int index_of_b, Stack<Integer> st, boolean first) {
    if (index_of_a >= ar1.length || index_of_b >= ar2.length) {
        st.pop();
        return;
    }

    // take from second if available
    if (!first) {
        for (int j = index_of_b; j < ar2.length; j++) {
            if (ar1[index_of_a] < ar2[j]) {
                st.push(ar2[j]);
                System.out.println(st);
                generateArrays(ar1, ar2, index_of_a + 1, j, st, true);
            }
        }
    }

    // take from first if available
    else if (first) {
        for (int i = index_of_a; i < ar1.length; i++) {
            if (ar1[i] > ar2[index_of_b]) {
                st.push(ar1[i]);
                generateArrays(ar1, ar2, i, index_of_a + 1, st, false);
            }
        }
    }

    st.pop();
}

Answer 4

抱歉，编写算法有点懒，但是您可以从代码中驱动它。下面是我的解决方案，您可以使用它

void Generate_all_possible_sorted_arrays_from_two_sorted_arrays(int[] a1,int[] a2){
    int[] array3=new int[a1.length+a2.length];// max length
    int flag=-1;
    for(int i=0;i<a1.length;i++){
        for(int j=0;j<a2.length;j++){
            if(a1[i]<a2[j]){
                System.out.println(a1[i]+" "+a2[j]);
                flag+=2;
                array3[flag-1]=a1[i];
                array3[flag]=a2[j];
                int k=i+1,l=j+1;
                findWave:for(;k<a1.length;k++){
                    if(a1[k]>array3[flag]){
                        for(;l<a2.length;l++){
                            if(a2[l]>a1[k]){
                                flag+=2;
                                array3[flag-1]=a1[k];
                                array3[flag]=a2[l];
                                for(int element=0;element<=flag;element++){
                                    System.out.print(array3[element]+" ");
                                }
                                System.out.println();
                             continue findWave;
                            }
                        }
                    }
                }
            flag=-1;
            }
        }
    }
    }

如何从两个排序数组的备用元素生成所有可能的排序数组？

4 个答案: