LeetCode第 70 场双周赛

A

class Solution {
public:
    int minimumCost(vector<int>& cost) {
        sort(cost.begin(), cost.end());
        vector<int> v;
        int sum = 0;
        for (int i = cost.size() - 1; i >= 0; i -- ) {
            if (v.size() < 3) 
                v.push_back(cost[i]);
            else {
                sum += v[0] + v[1];
                v.clear();
                v.push_back(cost[i]);
            }
        }
        if (v.size() > 0 && v.size() < 3) 
            for (auto x : v)
                sum += x;
        if (v.size() == 3) 
            sum += v[0] + v[1];
        return sum;
    }
};

B

class Solution {
public:
    int numberOfArrays(vector<int>& d, int lower, int upper) {
        long long maxx = 0, minn = 0;
        long long sum = 0;
        for (auto x : d) {
            sum += x;
            maxx = max(maxx, sum), minn = min(minn, sum);
        }
        long long start = lower - minn;
        if (upper < start + maxx)   return 0;
        else return upper - (maxx + start) + 1;
    }
};

C

class Solution {
public:
    struct node {
        int x, y, val, dist;
    };
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {1, 0, -1, 0};
    vector<vector<int>> highestRankedKItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
        int n = grid.size();
        int m = grid[0].size();
        vector<node> ans;
        vector<vector<bool>> st(n + 1, vector<bool>(m + 1, 0));
        function<void()> bfs = [&]() {
            queue<node> q;
            q.push({start[0], start[1], grid[start[0]][start[1]], 0});
            st[start[0]][start[1]] = 1;
            while (q.size()) {
                auto t = q.front();
                q.pop();
                if (t.val >= pricing[0] && t.val <= pricing[1]) ans.push_back(t);
                for (int i = 0; i < 4; i ++ ) {
                    int tx = t.x + dx[i];
                    int ty = t.y + dy[i];
                    if (tx < 0 || tx >= n || ty < 0 || ty >= m || st[tx][ty] ||grid[tx][ty] == 0) continue;
                    st[tx][ty] = true;
                    q.push({tx, ty, grid[tx][ty], t.dist + 1});
                }
            }
        };
        bfs();
        function<bool(node, node)> cmp = [&](node a, node b) {
            if (a.dist == b.dist) {
                if (a.val == b.val) {
                    if (a.x == b.x) return a.y < b.y;
                    return a.x < b.x;
                }
                return a.val < b.val;
            }
            return a.dist < b.dist;
        };
        sort(ans.begin(), ans.end(), cmp);
        vector<vector<int>> res;
        for (int i = 0; i < min(k, (int)ans.size()); i ++ ) {
            vector<int> v;
            v.push_back(ans[i].x);
            v.push_back(ans[i].y);
            res.push_back(v);
        }
        return res;
    }
};

D

class Solution {
public:
    const int MOD = 1e9 + 7;
    int numberOfWays(string corridor) {
        int ans = 1, cnt_s = 0, pre = 0;
        for (int i = 0; i < corridor.size(); ++i) {
            if (corridor[i] == 'S') {
                ++cnt_s;
                if (cnt_s >= 3 && cnt_s % 2) 
                    ans = (long) ans * (i - pre) % MOD;
                pre = i; 
            }
        }
        return cnt_s && cnt_s % 2 == 0 ? ans : 0; 
    }
};