[好题][思维][栈]双向排序 2021年蓝桥杯

题目描述

给定序列 (a1, a2, · · · , an) = (1, 2, · · · , n)，即 ai = i。
小蓝将对这个序列进行 m 次操作，每次可能是将 a1, a2, · · · , aqi 降序排列，或者将 aqi , aqi+1, · · · , an 升序排列。
请求出操作完成后的序列。

输入

输入的第一行包含两个整数 n, m，分别表示序列的长度和操作次数。
接下来 m 行描述对序列的操作，其中第 i 行包含两个整数 pi, qi 表示操作类型和参数。当 pi = 0 时，表示将 a1, a2, · · · , aqi 降序排列；当 pi = 1 时，表示将 aqi , aqi+1, · · · , an 升序排列。

输出

输出一行，包含 n 个整数，相邻的整数之间使用一个空格分隔，表示操作完成后的序列。

样例输入

3 3
0 3
1 2
0 2

样例输出

3 1 2

提示

【样例说明】
原数列为 (1, 2, 3)。 第 1 步后为 (3, 2, 1)。 第 2 步后为 (3, 1, 2)。 第 3 步后为 (3, 1, 2)。与第 2 步操作后相同，因为前两个数已经是降序了。
【评测用例规模与约定】
对于 30% 的评测用例，n, m ≤ 1000；
对于 60% 的评测用例，n, m ≤ 5000；
对于所有评测用例，1 ≤ n, m ≤ 100000，0 ≤ ai ≤ 1，1 ≤ bi ≤ n。

题意： 初始是一个1~n的序列，然后有m次操作，每次操作可能是把a1~ak降序处理或者是把ak~an升序处理，输出最后序列。

分析： 30%的数据可以直接sort暴力过去，当时比赛时也是这么骗分的......这里主要说下怎么处理1e5的数据量。对于给出的一系列升序降序操作其实是可以有两步简化的。

        第一步很好想，如果出现了连续同类型的排序操作就只处理其中长度最长的那个，这步简化后题目给出的操作一定是降序升序交替出现的了，同时第一次操作一定是降序操作，因为原序列已经是升序了。第二步简化是对于相邻的两次相同类型操作，如果在后面的操作长度大于等于在前面的操作长度，那就可以忽略掉在前面的操作以及其之后的一次操作。可能比较难理解，举个例子，一共有8个数，3次操作，第一次操作是第1~5个数降序，第二次操作是第3~8个数升序，第三次操作是第1~6个数降序，此时相邻的两次相同类型操作是第一次和第三次操作，它们都是降序处理，同时在后面的第三次操作长度是1~6大于在前面的第一次操作长度1~5，那么此时就可以忽略掉第一次操作以及其后的第二次操作，这三次操作等效于只处理第三次操作。在这步简化后题目给出的操作就是：降序升序交替出现且不管是升序还是降序其操作长度都是逐渐下降的。

        这时候就可以发现规律了，假如第一次操作是对第1~r个数降序，那么无论之后如何排序第r+1~n个数顺序一定是不变的，因为之后降序操作的长度一定不会超过r（上面说明过），而升序操作中因为它们本来就是最大的哪些数，也不会改变顺序，因此最终序列的第r+1~n个数就是r+1~n，若第二次操作是对第l~n个数升序，同理最终序列的第1~l-1个数就是r，r-1，......按降序从r开始填l-1个数字即可。这样就一步步地把最终序列两侧的数字填上了，最后只剩下第l~r个数没填了，在模拟的过程中也可以发现，这段数字升序降序是和最终有几次操作相关的，显然如果有奇数次有效操作那就是降序，反之升序。

具体代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
using namespace std;

vector<int> st[100005];
int a[100005];

signed main()
{
	int n, m, top = 0;
	cin >> n >> m;
	for(int i = 1; i <= m; i++)
	{
		int u, v;
		scanf("%d%d", &u, &v);
		if(top == 0 && u == 0)
		{
			++top;
			st[top].push_back(u);
			st[top].push_back(v);
		}
		else if(top) 
		{
			if(u == st[top][0] && (v <= st[top][1] && u == 0 || v >= st[top][1] && u == 1))//不用入栈
				continue;
			else//需要入栈 
			{
				//先弹出同类型且比当前操作短的
				if(u == 0 && u == st[top][0] && v > st[top][1])
					st[top--].clear();
				if(u == 1 && u == st[top][0] && v < st[top][1]) 
					st[top--].clear();
				//再成对弹出无效操作
				if(u == 0)
					while(top > 1 && st[top-1][1] <= v)
					{
						st[top--].clear();
						st[top--].clear();
					}
				else
					while(top > 1 && st[top-1][1] >= v)
					{
						st[top--].clear();
						st[top--].clear();
					}
				//然后入栈
				++top;
				st[top].push_back(u);
				st[top].push_back(v);
			}
		}
	}
	int temp = n;//开始倒序填数 
	int l = 1, r = n; 
	for(int i = 1; i <= top; i++)
	{
		if(i&1)//从后往前填 
		{
			for(int j = r; j > st[i][1]; j--)
				if(temp)//小细节，可能会因为[l, r]无法构成区间出错 
					a[j] = temp--;
			r = st[i][1];
		}
		else//从前往后填 
		{
			for(int j = l; j < st[i][1]; j++)
				if(temp)
					a[j] = temp--;
			l = st[i][1];
		}	
	}
	//中间部分填数 
	if(top&1)
		for(int i = l; i <= r; i++)
			a[i] = temp--;
	else
		for(int i = r; i >= l; i--)
			a[i] = temp--;
	for(int i = 1; i <= n; i++)
		printf("%d ", a[i]); 
    return 0;
}