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;
    }
};