双栈排序（栈+二分图）

牛客题面：双栈排序

题面大意：

给定一个整数 $n$ 和一个初始序列 $a$，其中序列 $a$ 的值为[1,n]不重复的正整数。
现在有以下四个操作，希望能够凭借这四个操作使得序列 $a$ 成为一个升序的序列。

1. 操作a：如果输入序列不为空，将第一个元素压入栈S1
2. 操作b：如果栈S1不为空，将S1栈顶元素弹出至输出序列
3. 操作c：如果输入序列不为空，将第一个元素压入栈S2
4. 操作d：如果栈S2不为空，将S2栈顶元素弹出至输出序列

让我们判断，初始序列 $a$ 是否能够通过以上四个操作得到升序序列，如果不能输出 $0$ ；如果可以输出字典序最小的操作序列。

思路：

当我们只考虑一个栈的时候，很显然有一个固定的操作：
在序列 $a$ 中从前往后遍历每个数，先将当前数压入栈中，如果之后的所有数值都比栈顶数值来得大，则需要将栈顶弹出，否则不弹出。

所以，当我们拓展到两个栈的时候，我们只要考虑当前数要压入第一个栈还是第二个栈就行了，其余操作与上述一致。

这里有一个很强的性质：
当两数 $a[i]<a[j],(i<j)$ 时，这两个数不存在于同一个栈中，当且仅当，存在 $k>j$ 时，有 $a[k]<a[i]<a[j]$。

证明如下：

充分性：
当 $a[i]$ 与 $a[j]$ 不在同一个栈，且它们后面都没有更小的数 $a[k]$ 时，则当前数进出栈操作必定不存在矛盾。
假设当前数为 $a[j]$，则有以下两种情况：

1. 所有大于 $a[j]$ 的数一定都在栈中。
2. 所有小于 $a[j]$ 的数一定都已经出栈。

如此所有对当前数 $a[j]$ 的操作都是顺利可行的。

必要性：
当存在一个 $a[k]<a[i]<a[j],(k<i<j)$时，假设当前数为 $a[j]$，则因为 $a[i]$ 和 $a[j]$ 之后都有一个更小的数 $a[k]$，所以 $a[i]$ 和 $a[j]$ 必须呆在栈里，这就会导致一个最终的序列出现逆序数，是与题面要求相矛盾的。所以，$a[i]$ 与 $a[j]$ 不能存在于同一个栈中。

由上述结论，我们可以让每一对存在于不同栈中的两个数分到两个集合中，这样最终可以抽象成一个图论模型：如果 $i$ 与 $j$ 满足上述不存在于同一个栈的条件，则在两个点间连一条边。

这样就可以判断是否是二分图，如果不是则说明至少出现一对不能出现在同一个栈的两个数存在于同一个栈了，这就不能得到升序序列；如果是，根据题目要求字典序最小，我们应该把从前往后遍历的当前数优先放入第一个栈中。

时间复杂度：$O(n^2)$

代码：

#include <bits/stdc++.h>
#define sc scanf
#define pf printf
using namespace std;
typedef long long LL;
const int N = 1010;

int n, a[N], f[N], color[N];
bool g[N][N];

//染色法判断二分图
bool dfs(int u, int c)
{
    color[u] = c;
    for(int i = 1; i <= n; i++) {
        if(g[u][i]) {
            if(color[i] == c) return false;
            else if(color[i] == -1 && !dfs(i, !c)) return false;
        }
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    //用f[i]来存储在 i 后面所有数的最小值。
    f[n + 1] = n + 1;
    for(int i = n; i; i--) f[i] = min(f[i + 1], a[i]);
    
    //邻接矩阵建图
    memset(g, false, sizeof g);
    for(int i = 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            if(a[i] < a[j] && f[j + 1] < a[i])
                g[i][j] = g[j][i] = true;
    
    //染色法判断是否是二分图
    memset(color, -1, sizeof color);
    for(int i = 1; i <= n; i++)
        if(color[i] == -1 && !dfs(i, 0)) {
        	//如果染色出现冲突，则不是二分图，直接输出0。
            cout << 0 << endl;
            return 0;
        }
    
    //用两个栈进行模拟。
    stack<int> stk1, stk2;
    int now = 1;
    for(int i = 1; i <= n; i++) {
    	//优先考虑对第一个栈进行操作。
        if(color[i] == 0) {
        	//将栈中可以出栈的元素全部先推出栈
        	//以此来保证当前数推进栈时，栈内所有元素都比当前数大
            while(stk1.size() && stk1.top() == now) {
                stk1.pop();
                cout << "b ";
                now ++;
            }
            stk1.push(a[i]);
            cout << "a ";
        }
        else {
        	//对第二个栈进行操作
        	//由于第一个栈弹出操作为 "b" 字典序比第二个栈的弹出操作 "c" 小
        	//所以第一个栈能弹出的也要直接弹出。
            while(true) {
                if(stk1.size() && stk1.top() == now) {
                    stk1.pop();
                    cout << "b ";
                    now ++;
                }
                else if(stk2.size() && stk2.top() == now) {
                    stk2.pop();
                    cout << "d ";
                    now ++;
                }
                else break;
            }
            stk2.push(a[i]);
            cout << "c ";
        }
    }
    //将剩余的元素弹出。
    while(true) {
        if(stk1.size() && stk1.top() == now) {
            stk1.pop();
            cout << "b ";
            now ++;
        }
        else if(stk2.size() && stk2.top() == now) {
            stk2.pop();
            cout << "d ";
            now ++;
        }
        else break;
    }
    cout << endl;
    
    return 0;
}