火車進站

描述	給定一個正整數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 }

 

使用遞歸和堆棧能夠明顯減小代碼量和細節上的考慮。

多使用模板類。