2.2 Just Sort

★实验任务
定两个序列 a b，序列 a 原先是一个单调递增的正数序列，但是由于某些 原因，使得序列乱序了，并且一些数丢失了（用 0 表示）。经过数据恢复后，找 到了正数序列 b ，且序列 a 中 0 的个数等于序列 b 的个数，打算使用序列 b 恢 复序列 a 。
对于序列 a 来说，我们可以交换两个位置上的非零的数，并且可以交换任意 次。序列 b 同样也可以进行任意次交换。
现在要将序列 b 填充到序列 a 中的值丢失的位置上，序列 b 中的每个数只能 填充一次，问最后构成的序列是否是单调递增的，如果是，则输出填充后的序列， 否则输出-1。

★数据输入
输入给定 N M，表示序列 a 和序列 b 的长度。
第一行为序列 a ，第二行为 序列 b。 题目保证除了 0 以外的数，在序列 a 和 b 中只出现一次。
数据保证:
80%的数据，N, M <= 100
100%的数据，N, M <= 100000, 0 <= a[i] <= 100000, 0 < b[i] <= 100000

★数据输出
如果最后序列 a 是单调递增的，输出该序列，否则输出-1。

★输入示例1
4 2
0 11 0 15
1 12
★输出示例 1
1 11 12 15
★输入示例2
4 2
0 0 11 15
1 12
★输出示例 2
-1

解题思路：
把序列b中的数据填到序列a中所有0所在的位置上，然后再将序列a进行升序排序，谁都做得到，这不是重点
重点是这个数据已经被恢复的序列a中，各个数据所在的位置，是否满足各个数据的"活动范围"
听起来很懵对吧？我来解释一下
显然我们可以从题面得知，在序列a恢复之前，序列a和序列b中数据的"站位"是有限制的：
“活动”就是题面里讲的任意次交换的过程
序列b中数据只能在序列a中0所在的那些位置里"活动"
序列a中数据只能在非0的那些位置里"活动"
这就叫做各个数据的"活动范围"
如果不满足这个活动范围的话，就输出-1

我们需要用到快速排序和二分查找这两个工具
先放个逃课版代码(无TLE)

//Matsuri
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#define MAX 200001
using namespace std;

int a[MAX],b[MAX],N,M;
bool id[MAX]; //记录数据是来自哪个数组的,1代表来自a[],0代表来自b[]
int aplace[MAX],bplace[MAX],ab[MAX]; // aplace[],bplace[]分别存a,b数组中数据可以待的位置的下标
// ab[]数组用于存储a[]中所有非0数据 + b[]中所有数据(b[]中可能有0) 
int abcnt=0; // ab[]的长度  
int apcnt=0; // aplace[]长度  
int bpcnt=0; // bplace[]长度  

int BinarySearch(int x,int t[],int lent) // 二分查找下标 
{
	int L=1,R=lent,mid;
	while(L<=R)
	{
		mid=(L+R)>>1;
		if (t[mid]==x) return x; //在"可以待的位置"里找到x了，满足活动范围
		else
		{
			if (x>t[mid]) L=mid+1;
			else R=mid-1;	
		}
	}
	return -1; // 没在"可以待的位置"里找到x，那么肯定不满足活动范围了
}


int main()
{
	scanf("%d%d",&N,&M); // a[]和b[]的长度 
	 
	for (int i=1;i<=N;i++)
	{
		scanf("%d",&a[i]);
		if (a[i]) 
		{
			aplace[++apcnt]=i; //存下标 
			ab[++abcnt]=a[i];
			id[a[i]]=1; 
		} 
		else bplace[++bpcnt]=i;
	}
	for (int i=1;i<=M;i++) 
	{
		scanf("%d",&b[i]);
		ab[++abcnt]=b[i];  
		id[b[i]]=0;
	}
	
	//这就叫逃课  
    sort(aplace+1,aplace+apcnt+1);
    sort(bplace+1,bplace+bpcnt+1);
    sort(ab+1,ab+abcnt+1);
	
	int r;
	for (int i=1;i<=abcnt;i++)
	{
		if (id[ab[i]]==1) r=BinarySearch(i,aplace,apcnt); // BinarySearch(要查的下标,待查数组,待查数组长度)
		else r=BinarySearch(i,bplace,bpcnt);
		if (r==-1) break;
	}
	
	if (r==-1) puts("-1");
	else 
	{
		for (int i=1;i<=abcnt;i++) printf("%d ",ab[i]);
	}
	return 0;
}

    // 需要头文件 #include<algorithm>
	sort(aplace+1,aplace+apcnt+1);
	sort(bplace+1,bplace+bpcnt+1);
	sort(ab+1,ab+abcnt+1);

sort()为C++标准库里自带的排序函数， 时间复杂度(稳定地)为O( nlogn )，可以积累一下
格式为sort(待排序数组的首地址,待排序数组的末地址)，这里的首末地址是由你自己指定的
默认为升序排序，如果你想要决定它的排序形式的话，就要用到它的第三个参数：
举例：sort( a+1,a+n+1,compare )

bool compare(int a,int b)
{
    return a<b; //升序排列，如果改为return a>b，则为降序
}

请特别注意一点： 举例说明，数组为a[]={3,1,5,4,2}，对该数组排序，应当用sort(a,a+5)而非sort(a,a+4)
为什么呢？因为sort()只会处理首地址到末地址前一位的数据，末地址数据不会被处理！
a[]数组中，下标从0到4依次为3,1,5,4,2,我们写sort(a,a+4)时，实际上只处理到了a[3]为止，想要全处理到则必须写sort(a,a+5)
第二种说法：sort()参数里从首地址到末地址是前闭后开的区间。

但我认为过分依赖STL是逃课行为，所以这是逃课版
快速排序那么常用那么常见你自己不懂不理解不会敲能行吗？

拒绝逃课，从自己写快速排序开始

//Matsuri
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#define MAX 200001
using namespace std;

int a[MAX],b[MAX],N,M;
bool id[MAX]; //记录数据是来自哪个数组的,1代表来自a[],0代表来自b[]
int aplace[MAX],bplace[MAX],ab[MAX]; // aplace[],bplace[]分别存a,b数组中数据可以待的位置的下标
// ab[]数组用于存储a[]中所有非0数据 + b[]中所有数据(b[]中可能有0) 
int abcnt=0; // ab[]的长度  
int apcnt=0; // aplace[]长度  
int bpcnt=0; // bplace[]长度  


void QuickSort(int t[],int l,int r) //快速排序 QuickSort(待排序数组,数组左上限,数组右上限) 
{
	if (l<r)
	{
		int key=l; // 选取当前数组最左边的数字为"基准",我们需要保证在基准左边的数都比基准小,在基准右边的都比基准大 
		int i=l,j=r; // 左哨兵i,右哨兵j 
		while (i!=j)
		{
			/*	
			左右哨兵的任务就是"碰头",并且在碰头过程中将"位置不对的数字"通过交换来更正 
			右哨兵: 向左移动,直到找到比基准小的数,停下,换左哨兵行动 
			左哨兵: 向右移动,直到找到比基准大的数,停下,此时左右哨兵均找到了"位置不对的数字",那么就执行"更正"  
			切记：右哨兵j先"行动"！ 
			*/
			while (i<j && t[j]>=t[key]) j--; //右哨兵行动 
			while (i<j && t[i]<=t[key]) i++; //左哨兵行动
			if (i<j) swap(t[i],t[j]); 
		}
		swap(t[key],t[i]); // 此时左右哨兵已经碰头了
		QuickSort(t,l,i);
		QuickSort(t,i+1,r);  
	}  
}

int BinarySearch(int x,int t[],int lent) // BinarySearch(要查的下标,待查数组,待查数组长度)
{
	int L=1,R=lent,mid;
	while(L<=R)
	{
		mid=(L+R)>>1;
		if (t[mid]==x) return x;
		else
		{
			if (x>t[mid]) L=mid+1;
			else R=mid-1;	
		}
	}
	return -1;
}


int main()
{
	scanf("%d%d",&N,&M); // a[]和b[]的长度 
	 
	for (int i=1;i<=N;i++)
	{
		scanf("%d",&a[i]);
		if (a[i]) 
		{
			aplace[++apcnt]=i; //存下标 
			ab[++abcnt]=a[i];
			id[a[i]]=1; 
		} 
		else bplace[++bpcnt]=i;
	}
	for (int i=1;i<=M;i++) 
	{
		scanf("%d",&b[i]);
		ab[++abcnt]=b[i];  
		id[b[i]]=0;
	}
	
	QuickSort(aplace,1,apcnt);
	QuickSort(bplace,1,bpcnt);
	QuickSort(ab,1,abcnt);
	
	int r;
	for (int i=1;i<=abcnt;i++)
	{
		if (id[ab[i]]==1) r=BinarySearch(i,aplace,apcnt); // 二分查找下标 
		else r=BinarySearch(i,bplace,bpcnt);
		if (r==-1) break;
	}
	
	if (r==-1) puts("-1");
	else 
	{
		for (int i=1;i<=abcnt;i++) printf("%d ",ab[i]);
	}
	return 0;
}

快速排序是一定要掌握的工具，其他博客讲解的很详细了，建议自己去吸收理解

但是这个非逃课版…emmmmmm
TLE了…
为什么不逃课反而要这样对我(全恼)

TLE原因在于快速排序的时间复杂度是不稳定的O(nlogn)，最差时间复杂度为O(n^2)
自己写的话应当拿归并排序堆排序什么的把它炸飞