Generate all possible sorted arrays from alternate elements of two given sorted arrays

http://www.geeksforgeeks.org/generate-all-possible-sorted-arrays-from-alternate-elements-of-two-given-arrays/

Given two sorted arrays A and B, generate all possible arrays such that first element is taken from A then from B then from A and so on in increasing order till the arrays exhausted. The generated arrays should end with an element from B.

For Example

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

思路：如果只需要输出最长的交替且排好序的数组，则可以使用类似于mergesort的方法，但是由于需要输出所有可能的arrays，这是一个组合的问题，所以很自然地想到用递归的方法解决，而用递归解决问题的关键是分析出问题的solution和子问题之间的联系：所以我们假设funtion alternateSort(A, aStart, B, bStart, min)可以输出所有A从index aStart开始，B从bStart开始，最小值大于min的交替数组，所以我们可以分析一下，当aStart=i, bStart=j, 最小值为min时的情况：

A: a1, a2, ..., ai, ..., al, al+1,..., am; (数组A的长度为m)

B: b1, b2, ..., bj, ..., bt, bt+1,..., bn; (数组B的长度为n)

step 1: 从ai开始找到第一个大于min的元素；假设是al;

step 2: 由于A中的元素和B中的元素需要交替且按照从小到大的顺序出现，则在B中找的元素必须大于al，假设为bt;

step 3: alternateSort(A, i, B, j, min)的输出包括：

al, bo;

al, bo + alternateSort(A, l+1, B, o+1, bo); (t <=o <= n)

alternateSort(A, l+1, B, t+1, min);

ap, bt;

ap, bt + alternateSort(A, p+1, B, t+1, bt); (al < ap < bt)

递归终止的条件：

aStart >= A.length || bStart >= B.length;

从aStart开始，在数组A中找不到比min大的数；

从bStart开始，在数组B中找不到比al大的数;

所以实现上述算法的java code如下：

public class solution{

　　public void alternateSort(int[] A, int[] B){

　　　　if((A.length == 0)||(B.length == 0)){
　　　　　　return;
　　　　}

　　　　ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
　　　　ret = alternateSort(A, 0, B, 0, Integer.MIN_VALUE);
　　　　printResult(ret);
　　}

　　private ArrayList<ArrayList<Integer>> alternateSort(int[] A, int aStart, int[] B, int bStart, int min){
　　　　ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
　　　　if((aStart >= A.length)||(bStart >= B.length)){
　　　　　　return ret;
　　　　}
　　　　int i=aStart;
　　　　while((i < A.length)&&(A[i] < min)){
　　　　　　i++;
　　　　}
　　　　if(i >= A.length){
　　　　　　return ret;
　　　　}
　　　　int j = bStart;
　　　　while((j < B.length)&&(B[j] < A[i])){
　　　　　　j++;
　　　　}
　　　　if(j >= B.length){
　　　　　　return ret;
　　　　}

　　　　//{Ai, Bt} t >= j
　　　　//{Ai, Bt} + alternateSort(A, i+1, B, t+1, Bt);
　　　　for(int t = j; t < B.length; t++){
　　　　　　ArrayList<Integer> s = new ArrayList<Integer>();
　　　　　　s.add(A[i]);
　　　　　　s.add(B[t]);
　　　　　　ret.add(s);

　　　　　　ArrayList<ArrayList<Integer>> suffix = alternateSort(A, i+1, B, t+1, B[t]);
　　　　　　for(ArrayList<Integer> r : suffix){
　　　　　　　　ArrayList<Integer> ss = new ArrayList<Integer>();
　　　　　　　　ss.add(A[i]);
　　　　　　　　ss.add(B[t]);
　　　　　　　　ss.addAll(r);
　　　　　　　　ret.add(ss);
　　　　　　}
　　　　}

　　　　//{Al, Bj} Al < Bj
　　　　//{Al, Bj} + alternateSort(A, l+1, B, j+1, B[j]);
　　　　int l = i+1;
　　　　while((l < A.length)&&(A[l] < B[j])){
　　　　　　ArrayList<Integer> s = new ArrayList<Integer>();
　　　　　　s.add(A[l]);
　　　　　　s.add(B[j]);
　　　　　　ret.add(s);

　　　　　　ArrayList<ArrayList<Integer>> suffix = alternateSort(A, l+1, B, j+1, B[j]);
　　　　　　for(ArrayList<Integer> r:suffix){
　　　　　　　　ArrayList<Integer> ss = new ArrayList<Integer>();
　　　　　　　　ss.add(A[l]);
　　　　　　　　ss.add(B[j]);
　　　　　　　　ss.addAll(r);
　　　　　　　　ret.add(ss);
　　　　　　}

　　　　　　l++;
　　　　}

　　　　//alternateSort(A, i+1, B, j+1, min);
　　　　ret.addAll(alternateSort(A, i+1, B, j+1, min));

　　　　return ret;
　　}

　　private void printResult(ArrayList<ArrayList<Integer>> result){
　　　　for(ArrayList<Integer> s : result){
　　　　　　System.out.print("{");
　　　　　　for(int v : s){
　　　　　　　　System.out.print(v);
　　　　　　　　System.out.print(",");
　　　　　　}
　　　　　　System.out.println("}");
　　　　}
　　}

}