1. 题目

数组 A 是 [0, 1, ..., N - 1] 的一种排列，N 是数组 A 的长度。

• 全局倒置指的是 i,j 满足 0 <= i < j < N 并且 A[i] > A[j] ，
• 局部倒置指的是 i 满足 0 <= i < N 并且 A[i] > A[i+1] 。

当数组 A 中全局倒置的数量等于局部倒置的数量时，返回 true 。

示例 1:
输入: A = [1,0,2]
输出: true
解释: 有 1 个全局倒置，和 1 个局部倒置。

示例 2:
输入: A = [1,2,0]
输出: false
解释: 有 2 个全局倒置，和 1 个局部倒置。

注意:
A 是 [0, 1, ..., A.length - 1] 的一种排列
A 的长度在 [1, 5000]之间

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/global-and-local-inversions
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 解题

2.1 归并排序求逆序度

参考：剑指Offer - 面试题51. 数组中的逆序对（归并排序，求逆序对）

class Solution {
    
    
	int local = 0, global = 0;
	vector<int> tmp;
public:
    bool isIdealPermutation(vector<int>& A) {
    
    
    	if(A.size() <= 1) return true;
    	for(int i = 0; i < A.size()-1; ++i)
    		if(A[i] > A[i+1])
    			local++;
    	tmp.resize(A.size());
    	mergesort(A, 0, A.size()-1);
    	return local == global;//逆序度 == 局部逆序度
    }
    void mergesort(vector<int>& A, int l, int r)
    {
    
    
    	if(l >= r) return;
    	int mid = (l+r)/2;
    	mergesort(A, l, mid);
    	mergesort(A, mid+1, r);
    	int i = l, j = mid+1, k = 0;
    	while(i <= mid && j <= r)
    	{
    
    
    		if(A[i] <= A[j])
    			tmp[k++] = A[i++];
    		else//后序写入时，检查前面没有出队的（比我大，我在后面）
    		{
    
    
    			tmp[k++] = A[j++];
    			global += mid-i+1;
    		}
    	}
    	while(i <= mid)
            tmp[k++] = A[i++];
    	while(j <= r)
    		tmp[k++] = A[j++];
    	k = 0; i = l;
    	while(i <= r)
    		A[i++] = tmp[k++];
    }
};

时间复杂度 $O(n\log n)$
192 ms 33.8 MB

2.2 二分查找

• 全局倒置数量肯定 >= 局部倒置数量
• 检查每个数字 $A[i]$，它的前面 $[0,i-2]$ （相邻的不需要检查）存在比它大的数，肯定不满足题意

class Solution {
    
    
public:
    bool isIdealPermutation(vector<int>& A) {
    
    
    	set<int> s;
    	s.insert(A[0]);
    	for(int i = 2; i < A.size(); ++i)
    	{
    
    
    		if(s.lower_bound(A[i]+1) != s.end())
    		{
    
    	//前面存在比 A[i] 大的数
    			return false;
    		}
    		s.insert(A[i-1]);
    	}
    	return true;
    }
};

时间复杂度 $O(n\log n)$
396 ms 52.1 MB

2.3 一次遍历

优化：在第二种方法的基础上，记录前面的最大值即可

class Solution {
    
    
public:
    bool isIdealPermutation(vector<int>& A) {
    
    
    	int MAX = A[0];
    	for(int i = 2; i < A.size(); ++i)
    	{
    
    
    		if(MAX > A[i])
    			return false;
    		MAX = max(MAX, A[i-1]);
    	}
    	return true;
    }
};

时间复杂度 $O(n)$
148 ms 32.5 MB

我的CSDN博客地址 https://michael.blog.csdn.net/

长按或扫码关注我的公众号（Michael阿明），一起加油、一起学习进步！