luogu_1155: 双栈排序

洛谷1155：双栈排序

题意描述：

• 给定一个长度为\(n\)的序列\((n\leq 1000)\)，两个初始为空的栈，问是否能借助以下四种操作将序列排为升序。
• \(1:\)如果序列不为空，将第一个元素压入栈\(S_1\)。记为操作\(a\)。
• \(2:\)如果栈\(S_1\)不为空，将\(S_1\)栈顶元素弹出至输出序列。记为操作\(d\)。
• \(3:\)输入序列不为空，将第一个元素压入栈\(S_2\)。记为操作\(c\)。
• \(4:\) 如果栈\(S_2\)不为空，将\(S_2\)栈顶元素弹出至输出序列。记为操作\(d\)。

输出描述：

• 输出字典序最小的操作序列，如果不满足双栈排序性质，输出\(0\)。

思路：

• 写了半天单调栈+贪心+模拟被提醒是二分图。
• 写一篇题解纪念我逝去的三个小时。
• 首先有这样一个性质。
• 如果存在这种情况\(i<j<k\)且\(a(k)<a(i)<a(j)\)，那么\(a(i),a(j)\)不能处于同一个栈内，这是一个充分必要条件。
• 证明：
• 必要性：如果有\(i<j<k\)且\(a(k)<a(i)<a(j)\)，则因为\(a(i)\)和\(a(j)\)后面都存在一个更小的数\(a(k)\)，因此\(a(i),a(j)\)都不能从栈中被弹出。所以从栈底到栈顶的元素就不是一个单调递减的降序了，那么弹出的时候就会出现逆序对，因此\(a(i),a(j)\)不能分配到同一个栈中。
• 充分性：如果\(a(i),a(j)\)不满足上述条件，则在操作过程中一定不会出现矛盾。
  • 所有大于\(a(j)\)的元素，都一定在栈中；
  • 所有小于\(a(j)\)的元素，比如说\(a(i)<a(j)\)，则由于后面不存在\(a(k)<a(i)\)，因此\(a(i)\)已经出栈。
  • 所以将\(a(j)\)压入栈中，从栈底到栈顶依然可以保持降序，因此整个过程都是可以顺利进行的。
• 有了上述性质后，我们只需要将所有满足条件的点分到两个栈中，这一步可以转化为图论问题。
• 枚举所有点对，如果\(i,j\)满足能在一个栈条件，则在\(i,j\)加边。
• 当然枚举所有点对同时考虑上述条件，会发生一件很糟糕的事情。
  • 我枚举点对需要\(O(n^2)\)的时间复杂度，同时我需要向后扫描找到有没有更小的数字则需要\(O(n)\)的时间复杂度，总共就会要\(O(n^3)\)，无法通过。
• 想办法优化这一步，我们可以预处理\(f(i)=min(a_j)\)。\(j\)从\(i\)到\(n\)。
• 这样就可以\(O(n^2)\)枚举点对，判断是否有\(i,j\)满足条件，也就是\(f_{j+1}<a_i<a_j\)。
• 然后判断是否为二分图，从而判断是否能满足双栈排序的性质，可以用染色法。
• 又因为字典序要求最小，所以优先将点分配到\(S_1\)中。
• 之后模拟双栈排序，得出答案。

复杂度分析：

• 建图枚举所有点对\(O(n^2)\)。
• 染色法判定二分图\(O(n+m)\)。
• 模拟栈排序\(O(n)\)。
• 总时间复杂度为\(O(n^2)\)，可以通过。

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int INF = 0x3f3f3f3f;
int n, a[maxn], f[maxn];

int head[maxn], ver[maxn<<5], nex[maxn<<5], tot;
inline void add_edge(int x, int y){
    ver[++tot] = y; nex[tot] = head[x]; head[x] = tot;
}

int color[maxn];
bool dfs(int x, int c)
{
    color[x] = c;
    for(int i = head[x]; i; i = nex[i])
    {
        int y = ver[i];
        if(!color[y])
        {
            if(!dfs(y, 3 - c)) return false;
        }
        else if(color[y] == c) return false;
    }
    return true;
}

int main()
{
    scanf("%d", &n); f[n+1] = INF;
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);

    for(int i = n; i >= 1; i--) f[i] = min(f[i+1], a[i]);

    for(int i = 1; i < n; i++)
        for(int j = i + 1; j < n; j++)
        if(a[i] > f[j+1] && a[i] < a[j])
            add_edge(i, j), add_edge(j, i);

    bool flag = true;
    for(int i = 1; i <= n; i++)
    {
        if(!color[i])
        {
            if(!dfs(i, 1))
            {
                flag = false;
                break;
            }
        }
    }

    if(flag == false) puts("0");
    else
    {
        stack<int> stk1, stk2;

        int cnt = 1;
        for(int i = 1; i <= n; i++)
        {

            if(color[i] == 1)
            {
                stk1.push(a[i]);
                printf("a ");
            }
            else{
                stk2.push(a[i]);
                printf("c ");
            }
            while((!stk1.empty() && stk1.top() == cnt) || (!stk2.empty() && stk2.top() == cnt))
            {
                if(!stk1.empty() && stk1.top() == cnt)
                {
                    stk1.pop();
                    cnt++;
                    printf("b ");
                }
                else
                {
                    stk2.pop();
                    cnt++;
                    printf("d ");
                }
            }
        }
    }
    return 0;
}