洛谷P1155 双栈排序

这题什么毒瘤......之前看一直没思路，然后心说写个暴搜看能有多少分，然后就A了？？！

题意：给你一个n排列，求它们能不能通过双栈来完成排序。如果能输出最小字典序方案。

[update]这里面加了一个错误的剪枝。这是个假算法。

解：首先我们发现有一个策略，就是可以出栈的时候出栈，否则就在两个栈中选栈顶大于它且栈顶尽量小的那个入栈。如果这样还GG就无解。

但是这样不能保证字典序最小。因为入栈栈顶较小的可以保证决策包容性，但是可能你入另一个栈不会引起冲突。

于是想到搜索，T飞。

加上剪枝：如果先入的栈顶较小，那么不用入另一个栈。AC。

然后发现过不了hack数据:

5
2 4 1 3 5

这组数据在最后要先入栈5，再出栈4。

稍微调整一下搜索顺序就行了。AC。

#include <cstdio>
#include <algorithm>

const int N = 10010, INF = 0x3f3f3f3f;

int a[N], b[N], c[N], d[N], ta, tb, tc, td, p[N << 2], tp, n;

void DFS(int k) {
    /*
    printf("k = %d  tb = %d  tc = %d  td = %d 
", k, tb, tc, td);
    printf("b: ");
    for(int i = 1; i <= tb; i++) {
        printf("%d ", b[i]);
    }
    printf("
c: ");
    for(int i = 1; i <= tc; i++) {
        printf("%d ", c[i]);
    }
    printf("
ed: ");
    printf("%d 
", td); */

    if(td == n) {
        // 
        for(int i = 1; i <= tp; i++) {
            putchar(p[i] + 'a' - 1);
            if(i < tp) {
                putchar(' ');
            }
        }
        exit(0);
        return;
    }
    if(a[k] == d[td] + 1) {
        d[++td] = a[k];
        p[++tp] = 1;
        p[++tp] = 2;
        DFS(k + 1);
        td--;
        tp--;
        tp--;
        return;
    }
    
    if(a[k] < b[tb] && k <= n) {
        b[++tb] = a[k];
        p[++tp] = 1;
        DFS(k + 1);
        tp--;
        tb--;
        if(b[tb] < c[tc]) {
            return;
        }
    }
    
    if(b[tb] == d[td] + 1) {
        d[++td] = b[tb];
        tb--;
        p[++tp] = 2;
        DFS(k);
        tp--;
        b[++tb] = d[td];
        td--;
        return;
    }
    
    if(a[k] < c[tc] && k <= n) {
        c[++tc] = a[k];
        p[++tp] = 3;
        DFS(k + 1);
        tp--;
        tc--;
        return;
    }
    if(c[tc] == d[td] + 1) {
        d[++td] = c[tc];
        tc--;
        p[++tp] = 4;
        DFS(k);
        tp--;
        c[++tc] = d[td];
        td--;
        return;
    }
    
    return;
}

int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    
    b[0] = INF;
    c[0] = INF + 1;
    
    DFS(1);
    
    printf("0");
    return 0;
}
/**
10
10 2 8 1 7 9 3 4 5 6

a a c a b b c a a b a b a b a b d d b b

*/