leetcode周赛 238

A：水题

class Solution {
public:
    int sumBase(int n, int k) {
        int res=0;
        while(n){
            res+=n%k;
            n/=k;
        }
        return res;
    }
};

B：给定一个数组和一个可操作次数，每次操作可将某一个元素加一，问操作之后的最大的频数数目是多少。

数组排序之后。

性质一：答案的最终频数一定可以是原数组中的数

性质二：对于一个确定的目标，在往左寻找最大频数的过程中操作次数单调增加

二分解法

对于一个 i（目标） 和 j（左端）操作次数等于 (a [ i ] - a [ j ] ) + (a [ i ] - a [ j+1 ] ) + ....+(a [ i ] - a [ i ] ) = (j-i+1) a[i] - ( a[j]+a[j+1]+...+a[i] )

后者可用前缀和进行计算

typedef long long LL;
class Solution {
public:
    vector<LL> s;
    LL get_op(int i,int j,vector<int>&nums){
        return nums[j]*(j-i+1ll)-(s[j+1]-s[i]);
    }
    int maxFrequency(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());
        s.resize(nums.size()+1);
        for(int i=1;i<=nums.size();i++) s[i]=s[i-1]+nums[i-1];
        int res=0;
        for(int i=0;i<nums.size();i++){
            int l=0,r=i;
            while(l<r){
                int mid=l+r>>1;
                if(get_op(mid,i,nums)<=k){
                    r=mid;
                }else{
                    l=mid+1;
                }
            }
            res=max(res,i-l+1);
        }
        return res;
    }
};

设定i为区间左端点，j为区间右端点，将区间内全部的数变成nums [ j ] ，操作次数小于k

性质三：当 j 往右移动，左端点 i 同时跟着往右移动

 双指针算法

计算操作次数同样用前缀和

typedef long long LL;
class Solution {
public:
    vector<LL> s;
    LL get_op(int i,int j,vector<int>&nums){
        return nums[j]*(j-i+1ll)-(s[j+1]-s[i]);
    }
    int maxFrequency(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());
        s.resize(nums.size()+1);
        for(int i=1;i<=nums.size();i++) s[i]=s[i-1]+nums[i-1];
        int res=0;
        int i=0;
        for(int j=0;j<nums.size();j++){
            while(get_op(i,j,nums)>k){
                i++;
            }
            res=max(res,j-i+1);
        }
        return res;
    }
};

C：可以直接模拟求解，注意分类讨论即可。

class Solution {
public:
    int longestBeautifulSubstring(string s) {
        string p="aeiou";
        int res=0;
        for(int i=0;i<s.size();i++){
            if(s[i]!='a') continue;
            int j=i,k=0;
            while(j<s.size()){
                if(s[j]==p[k]) j++;
                else{
                    if(k==4) break;
                    if(s[j]==p[k+1]) j++,k++;
                    else break;
                }
                if(k==4)
                    res=max(res,j-i);//不需要加一，j-1才是确定的
            }
            i=j-1;
        }
        return res;
    }
};

D：线性规划问题。

单独分析 i 这个点。

对于 i 这个点前边和后边对他高度的限制如图所示。

我们可以通过记录截距来记录每一条直线，也就很容易算出一个点的最高高度是多少了。

但是这样的话我们还是得算1e9次，但是观察到总共只有1e5个限制。

假设 i 和 j 之间是没有别的限制的话，i，j 之间的最大高度就是 i 和 j 以及他们限制交点的最低点（如果焦点在i,j之间的话）

class Solution {
public:
    int maxBuilding(int n, vector<vector<int>>& h) {
        typedef long long LL;
        h.push_back({1,0});
        sort(h.begin(),h.end());
        if(h.back()[0]!=n){
            h.push_back({n,n-1});
        }
        LL m=h.size();
        vector<LL> f(m+1,INT_MAX),g(m+1,INT_MAX);
        f[0]=-1;
        for(int i=1;i<m;i++){
            int x=h[i][0],y=h[i][1];
            f[i]=min(f[i-1],(LL)y-x);
        }
        for(int i=m-1;i>=0;i--){
            int x=h[i][0],y=h[i][1];
            g[i]=min(g[i+1],(LL)y+x);
        }
        LL res=0;
        for(int i=0;i<m;i++){
            int x=h[i][0];
            if(i){//防止数组越界，计算h[i-1][0]和h[i][0]之间的最高建筑高度
                LL Y=(f[i-1]+g[i])/2;
                LL X=Y-f[i-1];
                if(x>=h[i-1][0]&&X<=h[i][0])
                    res=max(res,Y);
            }
            res=max(res,min(x+f[i],g[i]-x));
        }
        //下面这样写也是可以的
//         for(int i=0;i<m;i++){
//             int x=h[i][0];
//             if(i<m-1){
//                 LL Y=(f[i]+g[i+1])/2;
//                 LL X=Y-f[i];
//                 if(x>=h[i][0]&&X<=h[i+1][0])
//                     res=max(res,Y);
//             }
//             res=max(res,min(x+f[i],g[i]-x));
//         }
        
        return res;
    }
};