LeetCode232周赛

5701.仅执行一次字符串交换能否使两个字符串相等

记录不相同的次数和字符，如果不相同的大于2了，那就直接返回false

如果符合条件的话，那么t1,t2应该分别是对应两个字符串最后不相等的字符，那么再遍历一次，如果第一次不相等的地方，t1==s2[i] && t2==s1[i]，那么说明符合条件，否则返回false

class Solution {
public:
    bool areAlmostEqual(string s1, string s2) {
        int n=s1.size();
        char t1,t2,cnt=0;
        for(int i=0;i<n;i++){
            if(s1[i]!=s2[i])
            {
                t1=s1[i];
                t2=s2[i];
                cnt++;
            }
            if(cnt>2) return false;
        }
        for(int i=0;i<n;i++){
            if(s1[i]!=s2[i]){
                if(t1==s2[i] && t2==s1[i]) return true;
                else return false;
            }
        }
        return true;
    }   
};

5702.找出星型图的中心节点

用map记录，等于总数的即为答案

class Solution {
public:
    int findCenter(vector<vector<int>>& edges) {
        int n=edges.size();
        map<int,int>mp;
        for(int i=0;i<n;i++){
            for(int j=0;j<2;j++){
                mp[edges[i][j]]++;
            }
        }
        int res=0;
        for(auto c : mp){
            if(c.second == n) {
                res=c.first;
                break;
            }
        }
        return res;
    }
};

5703.最大平均通过率

首先是一个很容易知道的数学知识，如果分子分母同时增加1，那么这个值会变大，第二个就是要发现，如果每次分子分母都加1，那么增大的速率将会减缓。也就是说，虽然它的值再增大，但是它会增大的越来越慢。

知道了这个之后，我们看到题目是要求得最大平均通过率（即最大通过率），那么结合上面的数学特点，我们应该每次让增长程度最大的那个分数去增加，这样就可以保证在每次分配时，得到的总的通过率增加最大。

所以很明显，符合最大堆的特点，我们选择用C++中的priority_queue来做。

class Solution {
public:
    double avg(int x,int y)
    {
        return (x+1)*1.0/(y+1) - x*1.0/y;
    }
    double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
        priority_queue<tuple<double, int, int>> q;
        double ans = 0.;
        for (const auto& c: classes) {
            int x = c[0], y = c[1];
            double t=avg(x,y);
            q.emplace(t, x, y);
        }
        for (int i = 0; i< extraStudents; i++) {
            auto [d, x, y] = q.top();
            q.pop();
            q.emplace(avg(x+1,y+1), x + 1, y + 1);
        }
        while(!q.empty()){
            auto [t,x,y]=q.top();
            ans+=x*1.0/y;
            q.pop();
        }
        return ans / classes.size();
    }
};

5704.好子数组的最大分数

Maximum Score of a Good Subarray

这个good怎么翻译都不对劲哈哈哈。

这个题刚看见就是想的从K位置开始往左右寻找，然后不断找到最大值。

但是有个注意的地方在于，往两侧寻找的时候，如果当前的值是最小值，那么就尽可能的往在两侧扩展，因为这个问题的条件是区间内的最小值乘上宽度，所以如果确定了最小值了，就尽可能增大宽度。

那么由于数组中元素的最大值是2*10e4，所以我们可以让这个最小值不断递减，在递减的过程中会递减到目前宽度的数组最小值还要小的时候，那么此时，就又可以向两侧扩张了，直到全部扩张完或者已经到了最小值1的时候，此时便可以退出循环。

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int n=nums.size();
        int l=k,r=k;
        int mmin=nums[k];
        int res=-1;
        while(l>0 || r<n){
            while(l>0 && nums[l-1]>=mmin) l--;
            while(r<n-1 && nums[r+1]>=mmin) r++;
            int t=mmin*(r-l+1);
            res=max(res,t);
            mmin--;
            if(mmin<1) break;
        }
        return res;
    }
};