LeetCode--第180场周赛

LeetCode--第180场周赛

1380. 矩阵中的幸运数

    class Solution {
public:
    vector<int> luckyNumbers (vector<vector<int>>& matrix) {
        vector<int> ans;
        int m = matrix.size();
        int n = matrix[0].size();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n ; j++) {
                int f = 0 ;
                for(int k = 0 ; k < n ;k++) {
                    if((matrix[i][j] > matrix[i][k]) ) {
                        f = 1;
                        break;
                    }
                }
                for(int k = 0 ; k < m ;k++) {
                    if((matrix[i][j] < matrix[k][j]) ) {
                        f = 1;
                        break;
                    }
                }
                if (f != 1)
                    ans.push_back(matrix[i][j]);
            }
        }
        return ans;
    }
};

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

• 模拟栈的操作比较水
  
  

#include <vector>
class CustomStack {
public:
    vector<int> v;
    int maxsize;

    CustomStack(int maxSize) {
        maxsize = maxSize;

    }

    void push(int x) {
        if (v.size() >= maxsize) {
            return;
        }
        v.push_back(x);
    }

    int pop() {
        if(v.size() == 0) {
            return -1;
        }
        int a = v[v.size() - 1];
        v.pop_back();
        return a;
    }

    void increment(int k, int val) {
        for(int i = 0; i < k && i < v.size() ;i++ ) {
            v[i] += val;
        }
    }
};

1382. 将二叉搜索树变平衡

• 先中序遍历获得有序的顺序
• 再通过该顺序，重新创建一个二叉搜索树
• 返回新的二叉搜索树

/**
 * 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:
    TreeNode* balanceBST(TreeNode* root) {
        vector<TreeNode*> arr;
        dfs(root, arr);
        return construct(arr, 0, arr.size()-1);
    }

    void dfs(TreeNode* root, vector<TreeNode*>& arr) {
        if (!root) return;
        dfs(root->left, arr);
        arr.push_back(root);
        dfs(root->right, arr);
    }

    TreeNode* construct(vector<TreeNode*>& arr, int left ,int right) {
        if (left > right) return NULL;
        int mid = (left + right) / 2;
        arr[mid]->left = construct(arr, left, mid-1);
        arr[mid]->right = construct(arr, mid+1, right);
        return arr[mid];
    }
};

1383. 最大的团队表现值

首先我们对n个人进行排序，优先效率从大到小，然后我们维护一个堆(set或者priority_queue都可以)，堆中每次维护k个值，也就是我们所要选择的k个人。那么对于这前k个人来说的团队表现值就是sumv[k-1].efficiency，那么对于下一个人来说，他是第k+1个将他加入到堆中，然后我们删去堆中speed最小的人，由于efficiency是从大到小排序，那么删除的这个人的efficiency一定是大于这个第k+1个人的，所以不需要去考虑删除的efficiency，那么此时的团队表现值就是sumv[k].efficiency，就这样遍历到最后维护一个最大团队表现值就好了。

class Solution {
public:
   const int mod = 1e9 + 7;
    vector<pair<int,int> > v;
    typedef pair<int,int> p;
    multiset<int> s;

    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        for(int i=0;i<n;i++){
            v.push_back(p(speed[i], efficiency[i]));
        }
        sort(v.begin(), v.end(), [](const pair<int,int> a, const pair<int,int> b){
            if(a.second == b.second) return a.first > b.first;
            return a.second > b.second;
        });

        long long sum = 0;
        long long ans = 0;

        for(int i=0;i<n;i++){
            sum += v[i].first;
            s.insert(v[i].first);
            if(s.size() > k){
                sum -= *s.begin();
                s.erase(s.begin());
            }
            ans = max(ans, sum * v[i].second);
        }
        return ans % mod;
    }

};