火车进站

描述	给定一个正整数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.对全排列进行判断是否符合出栈的规定

  1 import java.util.Arrays;
  2 import java.util.Scanner;
  3 
  4 public class Main {
  5     public static void main(String[] args) {
  6         Scanner scanner = new Scanner(System.in);
  7         while (scanner.hasNext()) {
  8             int n = scanner.nextInt();
  9             int[] in = new int[n];
 10             for (int i = 0; i < n; i++) {
 11                 in[i] = scanner.nextInt();
 12             }
 13             int[] weight = new int[10];
 14             for (int i = 0; i < n; i++) {
 15                 weight[in[i]] = i + 1;
 16             }
 17             String[] range = A(n);
 18             for (int i = 0; i < range.length; i++) {
 19                 String tmp = "";
 20                 for (int j = 0; j < n; j++) {
 21                     tmp += in[Integer.valueOf(range[i].substring(j, j + 1)) - 1];
 22                 }
 23                 range[i] = tmp;
 24             }
 25 
 26             int[] ai = new int[range.length];
 27             for (int i = 0; i < range.length; i++) {
 28                 ai[i] = Integer.valueOf(range[i]);
 29             }
 30 
 31             int[] ans = new int[range.length];
 32             int amt = 0;
 33             for (int i = 0; i < ai.length; i++) {
 34                 int seq = ai[i];
 35                 int[] digits = new int[n];
 36                 for (int j = n - 1; j >= 0; j--) {
 37                     digits[j] = seq % 10;
 38                     seq /= 10;
 39                 }
 40                 boolean ok = true;
 41                 for (int j = 0; j < n; j++) {
 42                     int[] small = new int[n];
 43                     int flag = 0;
 44                     for (int k = j + 1; k < n; k++) {
 45                         if (weight[digits[k]] < weight[digits[j]])
 46                             small[flag++] = digits[k];
 47                     }
 48                     if (flag > 1) {
 49                         for (int k = 0; k < flag; k++) {
 50                             if (weight[small[k]] < weight[small[k + 1]]) {
 51                                 ok = false;
 52                                 break;
 53                             }
 54                         }
 55                     }
 56                     if (ok == false)
 57                         break;
 58                 }
 59                 // System.out.println(ai[i] + " " + ok);
 60                 if (ok == true) {
 61                     ans[amt++] = ai[i];
 62                 }
 63             }
 64 
 65             Arrays.sort(ans, 0, amt);
 66 
 67             for (int i = 0; i < amt; i++) {
 68                 int tmp = ans[i];
 69                 int[] digits = new int[n];
 70                 for (int j = n - 1; j >= 0; j--) {
 71                     digits[j] = tmp % 10;
 72                     tmp /= 10;
 73                 }
 74                 for (int j = 0; j < n - 1; j++) {
 75                     System.out.print(digits[j] + " ");
 76                 }
 77                 System.out.println(digits[n - 1]);
 78             }
 79         }
 80     }
 81 
 82     public static String[] A(int n) {
 83         if (n == 1) {
 84             String[] rst = new String[n];
 85             rst[0] = "1";
 86             return rst;
 87         } else if (n > 1) {
 88             String[] pre = A(n - 1);
 89             String[] rst = new String[n * pre.length];
 90             for (int i = 0; i < n; i++) {
 91                 for (int j = 0; j < pre.length; j++) {
 92                     String pres = pre[j];
 93                     int position = n - i;
 94                     if (position == n) {
 95                         rst[pre.length * i + j] = pre[j] + n;
 96                     } else if (position == 1) {
 97                         rst[pre.length * i + j] = n + pre[j];
 98                     } else {
 99                         rst[pre.length * i + j] = pre[j].substring(0,
100                                 position - 1)
101                                 + n
102                                 + pre[j].substring(position - 1);
103                     }
104                 }
105             }
106             return rst;
107         } else {
108             return null;
109         }
110     }
111 
112 }

 

2）递归求解

a.初始化一个队列和栈

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

 1 import java.util.LinkedList;
 2 import java.util.Queue;
 3 import java.util.Scanner;
 4 import java.util.Stack;
 5 
 6 public class Main {
 7 
 8     public static void main(String[] args) {
 9         Scanner scanner = new Scanner(System.in);
10         while (scanner.hasNext()) {
11             int n = scanner.nextInt();
12             Queue<Integer> queue = new LinkedList<Integer>();
13             Stack<Integer> stack = new Stack<Integer>();
14             for (int i = 0; i < n; i++)
15                 queue.add(scanner.nextInt());
16 
17             redo(queue, stack, "");
18         }
19 
20     }
21 
22     public static void redo(Queue q, Stack s, String ans) {
23         boolean qEmpty = q.isEmpty();
24         boolean sEmpty = s.isEmpty();
25 
26         if (qEmpty && sEmpty) {
27             System.out.println(ans.trim());
28             return;
29         }
30 
31         if (!sEmpty) {
32             Queue<Integer> qb = new LinkedList<Integer>(q);
33             Stack<Integer> sb = (Stack<Integer>) s.clone();
34             String str = ans;
35             str += (sb.pop() + " ");
36             redo(qb, sb, str);
37         }
38         if (!qEmpty) {
39             Queue<Integer> qb = new LinkedList<Integer>(q);
40             Stack<Integer> sb = (Stack<Integer>) s.clone();
41             sb.push(qb.poll());
42             redo(qb, sb, ans);
43         }
44     }
45 
46 }

 

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

多使用模板类。

转载于:https://www.cnblogs.com/Run-dream/p/5334861.html