LeetCode [1380 ~ 1383]

链接：https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix/
来源：LeetCode

1380. 矩阵中的幸运数(枚举)

  思路：首先在将每一行的最小值保存在一个 set 中，然后计算出每一列的最大值，对于这个最大值我们直接在 set 中寻找是否有这个值，如果有则将它加入到答案数组中，由于矩阵中的数字互不相同，所以不需要考虑重复的问题。

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

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

  思路：这里我直接使用了 $STL$

class CustomStack {
public:
    int Max;
    stack<int> s;
    CustomStack(int maxSize) {
        Max = maxSize;
    }
    
    void push(int x) {
        if ((int)s.size() < Max) s.push(x);
    }
    
    int pop() {
        int val = -1;
        if (s.size()) {
            val = s.top();
            s.pop();
        }
        return val;
    }
    
    void increment(int k, int val) {
        int n = s.size();
        int temp[n + 10];
        int cnt = n;
        while (s.size()) {
            while (s.size()) {
                temp[-- cnt] = s.top();
                s.pop();
            }
        }
        int len = min(k, n);
        for (int i = 0; i < len; ++ i) temp[i] += val;
        for (int i = 0; i < n; ++ i) s.push(temp[i]);
    }
};

/**
 * 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);
 */

1383. 最大的团队表现值(贪心)

  思路：题目中让我们至多选择 k 个值来保证结果最大，题目中有 efficiency 最小，所以我们首先按照 efficiency 从大到小排序，对于每一个 efficiency 我们都可以计算它的最大贡献，就是在当前 efficiency 之前(因为当前值是最小的)选择一些 speed 值，我们使用一个优先队列记录当前已经过的 speed 值，如果我们的选择超过了 k 个，那么就将最小的那一个弹出来，这样就可以保证一个最大值。

class Solution {
public:
    int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
        priority_queue<int, vector<int>, greater<int> > pq;
        vector<vector<int> > res;
        for (int i = 0; i < n; ++ i) res.push_back({speed[i], efficiency[i]});
        sort(res.begin(), res.end(), [](vector<int> v1, vector<int> v2) -> bool {
            return v1[1] > v2[1];
        });
        long long sum = 0, Max = 0;
        for (int i = 0; i < n; ++ i) {
            pq.push(res[i][0]);
            sum += res[i][0]; k --;
            if (k == -1) {
                k ++;
                sum -= pq.top();
                pq.pop();
            }
            Max = max(Max, sum * res[i][1]);
        }
        return Max % 1000000007;
    }
};