力扣 第 169 场双周赛(A~D)

A:3736. 最小操作次数使数组元素相等 III
签到题。

class Solution:
    def minMoves(self, nums: List[int]) -> int:
        return max(nums)*len(nums)-sum(nums)

B:3737. 统计主要元素子数组数目 I

数据范围小，枚举左端点和右端点就能过，注意这里有一个技巧，我之前这种都是写三重循环的。

但是其实可以枚举左端点之后，从左端点扫到尾，然后右端点从右往左枚举，同时维护一下外层循环的数据。

class Solution:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        n=len(nums)
        res=0
        for i in range(n):
            cnt=Counter(nums[:i+1])
            for j in range(i+1):
                if cnt[target]>(i-j+1)//2:
                    res+=1
                cnt[nums[j]]-=1
        return res

C:3738. 替换至多一个元素后最长非递减子数组

可以修改一个元素，要求nums数组最长不下降子数组最长为多少。

如果对于i，有nums[i-1]<=nums[i+1]，那么这个点最长的不下降子数组长度为1+左边+右边。

那么我们可以预处理好left和right数组，left[i]表示以nums[i]结尾的不下降子数组的最大长度，right同理。

此外，我们还需要考虑一下特殊情况，首先是不改，那么就是max(left)，这和max(right)是一样的。

其次，改首元素和尾元素ans=max(ans,1+right[1],1+left[n-2])。

之后枚举改元素nums[i]的情况。

class Solution:
    def longestSubarray(self, nums: List[int]) -> int:
        n=len(nums)
        left=[0]*n
        right=[0]*n
        left[0]=1
        for i in range(1,n):
            if nums[i]>=nums[i-1]:
                left[i]=left[i-1]+1
            else:
                left[i]=1
        right[n-1]=1
        for i in range(n-2,-1,-1):
            if nums[i]<=nums[i+1]:
                right[i]=right[i+1]+1
            else:
                right[i]=1
        ans=max(left)
        if n>1:
            ans=max(ans,1+right[1],1+left[n-2])
        for i in range(1,n-1):
            l_part=left[i-1]+1
            r_part=right[i+1]+1
            ans=max(ans,l_part,r_part)
            if nums[i+1]>=nums[i-1]:
                ans=max(ans,left[i-1]+right[i+1]+1)
        return ans

D:3739. 统计主要元素子数组数目 II
接B，数据范围到1e5，不能用双重循环做。

假设将nums[i]==target置为1，nums[i]!=target置为-1，那么要求的就是对于pre[i]，前面有多少个小于pre[i]的，注意pre[0]=1

可以用树状数组维护前面的每个pre的值有多少个，注意原数据的范围为[-n,n]，总共2*n+1个数据，树状数组必须保证数据大于1，所以映射到[1,2n+1]范围。

const int N = 2e5+10;
int tr[N];
int n;
int lowbit(int x){
    return x&-x;
}
void add(int x,int c){
    for(int i=x;i<=2*n;i+=lowbit(i))
        tr[i]+=c;
}
int query(int x){
    int ans=0;
    for(int i=x;i;i-=lowbit(i)){
        ans+=tr[i];
    }
    return ans;
}
class Solution {
public:
    long long countMajoritySubarrays(vector<int>& nums, int target) {
        n=nums.size();
        for(int i=0;i<=n*2;i++)
            tr[i]=0;
        vector<int> pre(n+1,0);
        for(int i=1;i<=n;i++){
            pre[i]=pre[i-1]+(nums[i-1]==target?1:-1);
        }
        long long ans=0;
        add(n+1,1);
        for(int i=1;i<=n;i++){
            if(pre[i]+n>0)
                ans+=query(pre[i]+n);
            add(pre[i]+n+1,1);
        }
        return ans;
    }
};