火车进站

描述	给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号。要求以字典序排序输出火车出站的序列号。
知识点	栈
运行时间限制	0M
内存限制	0
输入	有多组测试用例，每一组第一行输入一个正整数N（0<N<10），第二行包括N个正整数，范围为1到9。
输出	输出以字典序排序的火车出站序列号，每个编号以空格隔开，每个输出序列换行，具体见sample。
样例输入	3 1 2 3
样例输出	1 2 3 1 3 2 2 1 3 2 3 1 3 2 1

解析：这道题目将数据结构的时候有讲过类似的，一看到题目马上想到用栈来写，想了想要用递归，想着想着把自己绕进去了，自己拿暴力的方法写了一遍。

写完后参考别人的代码，很快写好了使用堆栈递归完成的方法。

1）暴力求解：

a.求出n个数字的全排列

b.对全排列进行判断是否符合出栈的规定

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int[] in = new int[n];
            for (int i = 0; i < n; i++) {
                in[i] = scanner.nextInt();
            }
            int[] weight = new int[10];
            for (int i = 0; i < n; i++) {
                weight[in[i]] = i + 1;
            }
            String[] range = A(n);
            for (int i = 0; i < range.length; i++) {
                String tmp = "";
                for (int j = 0; j < n; j++) {
                    tmp += in[Integer.valueOf(range[i].substring(j, j + 1)) - 1];
                }
                range[i] = tmp;
            }

            int[] ai = new int[range.length];
            for (int i = 0; i < range.length; i++) {
                ai[i] = Integer.valueOf(range[i]);
            }

            int[] ans = new int[range.length];
            int amt = 0;
            for (int i = 0; i < ai.length; i++) {
                int seq = ai[i];
                int[] digits = new int[n];
                for (int j = n - 1; j >= 0; j--) {
                    digits[j] = seq % 10;
                    seq /= 10;
                }
                boolean ok = true;
                for (int j = 0; j < n; j++) {
                    int[] small = new int[n];
                    int flag = 0;
                    for (int k = j + 1; k < n; k++) {
                        if (weight[digits[k]] < weight[digits[j]])
                            small[flag++] = digits[k];
                    }
                    if (flag > 1) {
                        for (int k = 0; k < flag; k++) {
                            if (weight[small[k]] < weight[small[k + 1]]) {
                                ok = false;
                                break;
                            }
                        }
                    }
                    if (ok == false)
                        break;
                }
                // System.out.println(ai[i] + " " + ok);
                if (ok == true) {
                    ans[amt++] = ai[i];
                }
            }

            Arrays.sort(ans, 0, amt);

            for (int i = 0; i < amt; i++) {
                int tmp = ans[i];
                int[] digits = new int[n];
                for (int j = n - 1; j >= 0; j--) {
                    digits[j] = tmp % 10;
                    tmp /= 10;
                }
                for (int j = 0; j < n - 1; j++) {
                    System.out.print(digits[j] + " ");
                }
                System.out.println(digits[n - 1]);
            }
        }
    }

    public static String[] A(int n) {
        if (n == 1) {
            String[] rst = new String[n];
            rst[0] = "1";
            return rst;
        } else if (n > 1) {
            String[] pre = A(n - 1);
            String[] rst = new String[n * pre.length];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < pre.length; j++) {
                    String pres = pre[j];
                    int position = n - i;
                    if (position == n) {
                        rst[pre.length * i + j] = pre[j] + n;
                    } else if (position == 1) {
                        rst[pre.length * i + j] = n + pre[j];
                    } else {
                        rst[pre.length * i + j] = pre[j].substring(0,
                                position - 1)
                                + n
                                + pre[j].substring(position - 1);
                    }
                }
            }
            return rst;
        } else {
            return null;
        }
    }

}

2）递归求解

a.初始化一个队列和栈

b.对每次火车入站进行考虑

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            Queue<Integer> queue = new LinkedList<Integer>();
            Stack<Integer> stack = new Stack<Integer>();
            for (int i = 0; i < n; i++)
                queue.add(scanner.nextInt());

            redo(queue, stack, "");
        }

    }

    public static void redo(Queue q, Stack s, String ans) {
        boolean qEmpty = q.isEmpty();
        boolean sEmpty = s.isEmpty();

        if (qEmpty && sEmpty) {
            System.out.println(ans.trim());
            return;
        }

        if (!sEmpty) {
            Queue<Integer> qb = new LinkedList<Integer>(q);
            Stack<Integer> sb = (Stack<Integer>) s.clone();
            String str = ans;
            str += (sb.pop() + " ");
            redo(qb, sb, str);
        }
        if (!qEmpty) {
            Queue<Integer> qb = new LinkedList<Integer>(q);
            Stack<Integer> sb = (Stack<Integer>) s.clone();
            sb.push(qb.poll());
            redo(qb, sb, ans);
        }
    }

}

使用递归和堆栈可以明显减少代码量和细节上的考虑。

多使用模板类。