力扣 第159场双周赛(A~C)

A.最小相邻交换至奇偶交替

给一个数组，一次操作能够将相邻两个元素互换，问最少多少次操作之后，能够使得数组奇偶相间。

首先我们考虑我们的目标序列该是什么样子，当我们在某个位置需要一个特定的奇数或者偶数时，我们肯定是拿最近的来填，所以我们按顺序将数组分成奇偶两个，然后从这两个数组中一边拿一个就构成了我们最终的目标序列。

当然，其中有一些细节，比如元素总数为偶数，我们需要考虑起始为奇数和偶数的情况，若元素总数为奇数，那么我们肯定是只能以更多的那个为起始，若奇数偶数之差大于等于2，则不存在目标序列。

那么现在的问题就变成了，从一个序列，到目标序列，最少需要多少次相邻交换，这个问题和逆序对数量是高度匹配的，所以我们提取目标序列的序号，然后求一遍逆序对，即为目标序列转换为原始序列的操作次数。

class Solution {
public:
    vector<int> back;
    int ans;
    vector<int> make_v(vector<int> t1,vector<int> t2){
        vector<int> res;
        int i=0,j=0;
        while(i<t1.size()||j<t2.size()){
            if(i<t1.size()) res.push_back(t1[i++]);
            if(j<t2.size()) res.push_back(t2[j++]);
        }
        return res;
    }
    
    //求逆序对数目，merge_sort
    void get(vector<int>& q,int l,int r){
        if(l>=r) return ;
        int mid=l+r>>1;
        get(q,l,mid);
        get(q,mid+1,r);
        int i=l,j=mid+1,k=l;
        while(i<=mid&&j<=r){
            if(q[i]<=q[j]) back[k++]=q[i++];
            else{
                back[k++]=q[j++];
                ans+=mid-i+1;
            }
        }
        while(i<=mid) back[k++]=q[i++];
        while(j<=r) back[k++]=q[j++];
        for(int k=l;k<=r;k++){
            q[k]=back[k];
        }
    }
    int minSwaps(vector<int>& nums) {
        int n=nums.size();
        back.resize(n);
        vector<int> v0,v1;
        for(int i=0;i<nums.size();i++){
            if(nums[i]%2==0) v0.push_back(i);
            else v1.push_back(i);
        }
        int n0=v0.size(),n1=v1.size();
        if(abs(n0-n1)>=2) return -1;
        int res=INT_MAX;
        if(nums.size()%2==1){
            if(v0.size()<v1.size()) swap(v0,v1);
            vector<int> t;
            int i=0,j=0;
            vector<int> v=make_v(v0,v1);
            ans=0;
            get(v,0,v.size()-1);
            res=min(res,ans);
        }else{
            vector<int> tmp1=make_v(v0,v1);
            vector<int> tmp2=make_v(v1,v0);
            ans=0;
            get(tmp1,0,tmp1.size()-1);
            res=min(res,ans);
            
            ans=0;
            get(tmp2,0,tmp2.size()-1);
            res=min(res,ans);
        }
        return res;
    }
};

B.找到最大三角形面积

给定坐标系上n个点，问底边与坐标轴平行的最大三角形面积是多少，为避免除以2，返回三角形面积的两倍。

三角形面积为底乘高，高可用min和max来维护，比如要求一个底与y轴平行，位于x=2的，底为base的三角形的最大面积，那么显然S=max(x-minx,maxx-x)*base。

那么我们需要维护三角形的底最大为多少即可。

typedef long long LL;
class Solution {
public:
    long long maxArea(vector<vector<int>>& cor) {
        int n=cor.size();
        if(n<3) return -1;
        int minx=INT_MAX,maxx=INT_MIN;
        int miny=INT_MAX,maxy=INT_MIN;
        map<int,pair<int,int>> xg,yg;//xg[x]为当前x值下，最大的y值和最小的y值分别是多少
        for(int i=0;i<n;i++){
            int x=cor[i][0],y=cor[i][1];
            minx=min(minx,x);
            maxx=max(maxx,x);
            miny=min(miny,y);
            maxy=max(maxy,y);
            if(!xg.count(x)) xg[x]={y,y};
            else{
                xg[x].first=min(xg[x].first,y);
                xg[x].second=max(xg[x].second,y);
            }
            if(!yg.count(y)) yg[y]={x,x};
            else{
                yg[y].first=min(yg[y].first,x);
                yg[y].second=max(yg[y].second,x);
            }
        }
        LL ans=-1;
        for(auto [x,yrange]:xg){
            LL base = yrange.second-yrange.first;//底边长
            if(base==0) continue;
            LL height = max(x-minx,maxx-x);
            ans=max(ans,base*height);
        }
        for(auto [y,xrange]:yg){
            LL base = xrange.second-xrange.first;
            if(base==0) continue;
            LL height = max(y-miny,maxy-y);
            ans=max(ans,base*height);
        }
        if(ans==0) return -1;
        return ans;
    }
};

 C.计数质数间隔平衡子数组

给定一个数组，问有多少个子数组满足其中至少两个质数，而且最大的质数减去最小的质数小于等于k。

显然，当子数组的右端点右移时，左端点要不保持不动，要不跟着右移，所以可以用双指针来解决这个问题。

再维护当前子数组的最大质数和最小质数，即可O(1)判断小于等于k，再维护一个质数队列。

const int N = 5e4+10;
class Solution {
public:
    vector<bool> primes;
    void init(){
        primes.resize(N);
        for(int i=2;i<N;i++){
            if(primes[i]==false)
                for(int j=i+i;j<N;j+=i)
                    primes[j]=true;
        }
    }
    bool isprime(int x){
        if(x<=1) return false;
        return !primes[x];
    }
    int primeSubarray(vector<int>& nums, int k) {
        init();
        deque<int> maxx,minn,p;
        int i=0;
        int n=nums.size();
        int res=0;
        for(int j=0;j<n;j++){
            if(isprime(nums[j])){
                while(!maxx.empty()&&nums[maxx.back()]<=nums[j]) maxx.pop_back();
                maxx.push_back(j);
                while(!minn.empty()&&nums[minn.back()]>=nums[j]) minn.pop_back();
                minn.push_back(j);
                p.push_back(j);
                while(!maxx.empty()&&!minn.empty()&&i<=j&&
                        nums[maxx.front()]-nums[minn.front()]>k){
                    i++;
                    while(!maxx.empty()&&maxx.front()<i) maxx.pop_front();
                    while(!minn.empty()&&minn.front()<i) minn.pop_front();
                    while(!p.empty()&&p.front()<i) p.pop_front();
                }
            }
            if(p.size()>=2){
                int t=p[p.size()-2];
                res+=t-i+1;
            }
        }
        return res;
    }
};