hw火车进站

火车进站

描述
给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号，火车站只有一个方向进出，同时停靠在火车站的列车中，只有后进站的出站了，先进站的才能出站。
要求输出所有火车出站的方案，以字典序排序输出。
数据范围：1<=n<=10
进阶：时间复杂度：O(n!)，空间复杂度：O(n)
输入描述：
有多组测试用例，每一组第一行输入一个正整数N（0

输出描述：
输出以字典序从小到大排序的火车出站序列号，每个编号以空格隔开，每个输出序列换行，具体见sample。

示例1
输入：
3
1 2 3

输出：
1 2 3
1 3 2
2 1 3
2 3 1
3 2 1

说明：
第一种方案：1进、1出、2进、2出、3进、3出
第二种方案：1进、1出、2进、3进、3出、2出
第三种方案：1进、2进、2出、1出、3进、3出
第四种方案：1进、2进、2出、3进、3出、1出
第五种方案：1进、2进、3进、3出、2出、1出
请注意，[3,1,2]这个序列是不可能实现的。

解答过程：

采用递归。judge函数用于判断当前出站顺序是否正确，每次将入栈序号存入stk栈中，如果当前stk栈顶元素和出站顺序相同，则可以出站，最后如果stk为空，表示这个出站顺序是正确的。

dfs中用一个访问数组记录当前序号是否被访问过，如果当前元素在此次排列中还没被访问过，则访问当前元素，继续递归；如果当前元素被访问过，则遍历下一个元素。递归可以遍历所有可能的排列，最后判断每种排列的可行性。

#include<iostream>
#include<stack>
using namespace std;

bool visit[15]={0};
int stackIn[15],stackOut[15];
int n;

bool judge(){
    stack<int> stk;
    int index=1;
    for(int i=1;i<=n;++i){
        stk.push(stackIn[i]);
        while(index<=n && !stk.empty() && stk.top()==stackOut[index] ){
            stk.pop();
            ++index;
        }
    }
    return stk.empty();
}

void dfs(int step){
    for(int i=1;i<=n;++i){
        if(visit[i]==0){
            visit[i]=1;
            stackOut[step]=i;
            if(step==n){
                if(judge()){
                    for(int j=1;j<=n;++j){
                        cout<<stackOut[j]<<" ";
                    }
                    cout<<endl;
                }
            }
            else{
                dfs(step+1);
            }
            visit[i]=0;
        }
    }
}

int main(){
    while(cin>>n){
        for(int i=1;i<=n;++i){
            cin>>stackIn[i];
        }
        dfs(1);
    }
    return 0;
}