*Leetcode 775. Global and Local Inversions

https://leetcode.com/contest/weekly-contest-69/problems/global-and-local-inversions/

第一反应是暴力做法，O(nlogn))逆序数写出来bug了。需要重新写一下。

然后想了下可以O(n)，只用修正local的逆序，然后看是不是一个有序数列就行

class Solution {
public:
    
    int inverse_cnt(vector<int>&nums, int l, int r) {
        if (l >= r) {
            return 0;
        }
        if (l + 1 == r) {
             if(nums[l] > nums[r]) {
                 swap(nums[l], nums[r]);
                 return 1;
             } else {
                 return 0;
             }
        }
        int mid = (l + r) / 2;
        int ret = inverse_cnt(nums, l, mid);
        ret += inverse_cnt(nums, mid+1, r);
        // int bigger = 0;
        int lptr = l,  rptr = mid+1;
        vector<int> tmp;
        while (lptr <= mid && rptr <= r) {
            if (nums[lptr] > nums[rptr]) {
                tmp.push_back( nums[rptr] );
                rptr ++;
                ret += (mid - lptr + 1); //(rptr - mid + 1);
            } else {
                tmp.push_back( nums[lptr] );
                lptr ++;
            }
        }
        
        while (lptr <= mid) {
            tmp.push_back(nums[lptr++]);
            if (nums[lptr] > nums[r]) ret += (mid - lptr + 1);
        }
        while (rptr <= r) tmp.push_back(nums[rptr++]);
        
        for (int i = l; i <= r; i++) {
            nums[i]= tmp[i- l];
        }
        
        return ret;
    }
    
    int local_inverse_cnt(vector<int> &nums) {
        int ret = 0;
        for (int i = 0; i < nums.size()-1; i++) {
            if (nums[i] > nums[i+1]) ret ++;
        }
        return ret;
    }
    
    bool isIdealPermutation(vector<int>& A) {
        int a1 = local_inverse_cnt( A );
        int a2 = inverse_cnt(A, 0, A.size()-1); 
        // return local_inverse_cnt( A ) == inverse_cnt(A, 0, A.size()-1);
        // cout << a1 << "->" << a2 << endl;
        return a1 == a2;
    }
};

class Solution {
public:
    
    int local_inverse_cnt(vector<int> &nums) {
        int ret = 0;
        for (int i = 0; i < nums.size()-1; i++) {
            if (nums[i] > nums[i+1]) {
                swap(nums[i], nums[i+1]);
                i++;
                ret ++;
                
            }
        }
        return ret;
    }
    
    int check(vector<int> &nums) {
        int ret = 0;
        for (int i = 0; i < nums.size()-1; i++) {
            if (nums[i] > nums[i+1]) {
                ret ++;
                
            }
        }
        return ret;
    }
    
    
    bool isIdealPermutation(vector<int>& A) {
        local_inverse_cnt(A);
        return 0 == check(A);
    }
};