火车进站，如何思考？

结合上两篇文章，

https://blog.youkuaiyun.com/sophie1314/article/details/91372295，出栈入栈队列

https://blog.youkuaiyun.com/sophie1314/article/details/91346647，Java实现全排列

我们不难有想法>>可以先给火车编号进行全排列，再对所有的全排列进行分析，是否是合法的出栈队列，若是，则保存到Set集合中，最后输出，也就是最后的火车进站序列。

代码如下：

package test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        Object[] arr = new  Object[n];
        for (int i=0;i<n;i++){
            arr[i]=in.nextInt();
        }
        ArrayList<Object[]> list = new ArrayList<Object[]>();
        FullPermutation permutation = new FullPermutation();
        permutation.perm(arr, 0, n, list);
        for (Object[] o : list) {
            if (isLegal(arr, o,n)){
                for (int i=0;i<3;i++){
                    System.out.printf(o[i]+" ");

                }
                System.out.println();
            }

        }
    }

    public static boolean isLegal(Object[] in, Object[] out, int n) {
        if (in.length != out.length) {
            return false;
        }
        LinkedList<Object> stack = new LinkedList<Object>();
        int i = 0;
        int j = 0;
        while (i < in.length) {
            if (in[i] == out[j]) {//入栈队列第i个元素==出栈队列第j（i==j）个元素，则同时向后移，不入栈
                i++;
                j++;
            } else {//入栈队列第i个元素！=出栈队列第j个元素
                if (stack.isEmpty()) {//
                    stack.push(in[i]);
                } else {//如果栈不为空，比较栈顶元素和出栈队列元素，若相等，则栈顶元素出栈，j++
                    Object top = stack.peek();
                    if (top == out[j]) {
                        stack.pop();
                        j++;
                    } else {
                        if (i < n) {
                            stack.push(in[i]);
                            i++;
                        }
                    }
                }
            }

        }
            while (!stack.isEmpty() && j < n) {
                Object top = stack.peek();
                if (top == out[j]) {
                    j++;
                    stack.pop();
                } else {
                    return false;
                }
            }

        return true;
    }
}

public class FullPermutation {
   
    public static void perm(Object[] arr, int k, int length, ArrayList<Object[]> result) {
        //只有一个数，则直接输出
        if (k==length-1){
            Object[] b=arr.clone();
            result.add(b);
        }else {
            for (int i=k;i<length;i++){
                if (IsSwap(arr,k,i)) {
                    swap(arr, k, i);
                    perm(arr, k + 1, length,result);
                    swap(arr, k, i);
                }
            }
        }
    }

    private static boolean IsSwap(Object[] arr, int begin, int end) {
        for (int i=begin;i<end;i++)
            if (arr[i]==arr[end])return false;
        return true;
    }

    private static void swap(Object[] arr, int k, int i) {
        Object temp;
        temp=arr[k];
        arr[k]=arr[i];
        arr[i]=temp;
    }


}

================================================================================================

我们也可以采用递归的方式：

       采用递归的方法，递归函数的参数为当前待进站火车、站中火车、已出站火车的值所组成的三元组，递归结束条件 是，未进站火车和站中火车均为空，此时输出已出站火车即为所有出站的一种可能，递推关系为对于当前情况有让下 一辆火车进站或让站中的一辆火车出站两种可能，对于两种可能分别调用递归函数，即可得出问题的解，大家可以思考一下。