LeetCode 第180场周赛 题解

传送门

A 矩阵中的幸运数

题目大意

给出一个 m * n 的矩阵，矩阵中的数字各不相同 。按任意 顺序返回矩阵中的所有幸运数。
幸运数是指矩阵中满足同时下列两个条件的元素：
在同一行的所有元素中最小
在同一列的所有元素中最大

解题思路

模拟模拟

代码

class Solution {
public:
    int Max[55],Min[55];
    vector<int> luckyNumbers (vector<vector<int>>& matrix) {
        int n=matrix.size();
        int m=matrix[0].size();
        for (int i=0;i<n;++i)
        {
            Min[i]=matrix[i][0];
            for (int j=1;j<m;++j)
                Min[i]=min(Min[i],matrix[i][j]);
        }
        for (int i=0;i<m;++i)
        {
            Max[i]=matrix[0][i];
            for (int j=1;j<n;++j)
                Max[i]=max(Max[i],matrix[j][i]);
        }
        vector<int> ans;
        for (int i=0;i<n;++i)
            for (int j=0;j<m;++j)
            {
                if (matrix[i][j]==Min[i]&&matrix[i][j]==Max[j])
                    ans.push_back(matrix[i][j]);
            }
        return ans;
    }
};

B 设计一个支持增量操作的栈

题目大意

维护一个有元素个数上限的栈，支持压入、弹出、给栈底的k个元素都加上一个值val。
有趣的是数据范围很小。

解题思路

暴力暴力

代码

class CustomStack {
public:
    int top,ms;
    int stack[1005];
    
    CustomStack(int maxSize) {
        top=-1;
        memset(stack,0,sizeof(stack));
        ms=maxSize;
    }
    
    void push(int x) {
        if (top<ms-1)
            stack[++top]=x;
    }
    
    int pop() {
        if (top>=0)
        {
            --top;
            return stack[top+1];
        }
        else
        {
            return -1;
        }
    }
    
    void increment(int k, int val) {
        for (int i=0;i<min(k,top+1);++i)
            stack[i]+=val;
    }
};

/**
 * Your CustomStack object will be instantiated and called as such:
 * CustomStack* obj = new CustomStack(maxSize);
 * obj->push(x);
 * int param_2 = obj->pop();
 * obj->increment(k,val);
 */

C 将二叉搜索树变平衡树

题目大意

给出一个二叉搜索树，返回一个平衡的二叉搜索树

解题思路

怎么转的话没想过，直接遍历把元素扒下来之后二分建树

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int n;
    int seq[10005];
    void get_seq(TreeNode* p)
    {
        if (p->left!=NULL)
        {
            get_seq(p->left);
            delete p->left;
        }
        seq[++n]=p->val;
        if (p->right!=NULL)
        {
            get_seq(p->right);
            delete p->right;
        }
    }
    void build(int l,int r,TreeNode* p)
    {
        int mid=(l+r)>>1;
        p->val=seq[mid];
        if (l<mid)
        {
            TreeNode* pl=new TreeNode;
            p->left=pl;
            build(l,mid-1,pl);
        }
        if (mid<r)
        {
            TreeNode* pr=new TreeNode;
            p->right=pr;
            build(mid+1,r,pr);
        }
    }
    TreeNode* balanceBST(TreeNode* root) {
        n=0;
        memset(seq,0,sizeof(seq));
        get_seq(root);
        sort(seq+1,seq+n+1);
        build(1,n,root);
        return root;
    }
};

D 最大的团队表现值

题目大意

公司有编号为 1 到 n 的 n 个工程师，给你两个数组 speed 和 efficiency ，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的 ​​​​​​最大团队表现值 ，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。
团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。

解题思路

我要是刚开始看见了最多两个字我就不会有罚时我要是没有罚时我就有前50我要是有前50我就有300金币了哼！

排序之后枚举效率的最小值，用一个堆维护一下最大的k个速度值。当然，当堆中元素不足k个的时候也要取一下max哦，因为人家说的是最多k个呢~

代码

int cmp(vector<int> a, vector<int> b)
{
    return a[1]>b[1];
}
class Solution {
public:
    int Mod=1000000007;
    priority_queue < int, vector<int>, greater<int> > q;
    
    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        vector<vector<int>> worker;
        for (int i=0;i<n;++i)
            worker.push_back({speed[i],efficiency[i]});
        sort(worker.begin(),worker.end(),cmp);
        
        long long ssum=(long long)worker[0][0];
        long long ans=ssum*(long long)worker[0][1];
        q.push(worker[0][0]);
        for (int i=1;i<k;++i)
        {
            ssum+=(long long)worker[i][0];
            ans=max(ans,ssum*(long long)worker[i][1]);
            q.push(worker[i][0]);
        }
        for (int i=k;i<n;++i)
        {
            int Min=q.top();
            if (Min<worker[i][0])
            {
                q.pop();
                q.push(worker[i][0]);
                ssum-=(long long)Min;
                ssum+=(long long)worker[i][0];
            }
            ans=max(ans,ssum*(long long)worker[i][1]);
        }
        return (int)(ans%Mod);
    }
};