【2022/03/13-第284场单周赛】复盘

总结

Q4临时找了堆优化的dijkstra，写成模板以后用了。

Q1.找出数组中的所有 K 近邻下标

对每个key值左右两边都标记（可以优化时间）。

class Solution {
public:
    vector<int> findKDistantIndices(vector<int>& nums, int key, int k) {
        int n = nums.size();
        vector<int> h(n, 0);
        for(int i = 0; i < n; ++i){
            if(nums[i] == key){
                for(int j = 0; j <= k; ++j){
                    if(i - j >= 0) h[i - j] = 1;
                    if(i + j < n) h[i + j] = 1;
                }
            }
        }
        vector<int> ret;
        for(int i = 0; i < n; ++i){
            if(h[i]) ret.push_back(i);
        }
        return ret;
    }
};

Q2.统计可以提取的工件

标记所有挖过的格子，然后遍历工件。

class Solution {
public:
    int digArtifacts(int n, vector<vector<int>>& artifacts, vector<vector<int>>& dig) {
        int ret = 0;
        set<pair<int, int>> digged;
        for(auto i : dig){
            digged.insert({i[0], i[1]});
        }
        for(auto i : artifacts){
            int flag = 1;
            int lupx = i[0], lupy = i[1], rdownx = i[2], rdowny = i[3];
            for(int i = lupx; i <= rdownx; ++i){
                for(int j = lupy; j <= rdowny; ++j){
                    if(digged.find({i, j}) == digged.end()){
                        flag = 0;
                        break;
                    }
                }
            }
            ret += flag;
        }
        return ret;
    }
};

Q3.K 次操作后最大化顶端元素

只有坐标为k-1的数没办法最后留在顶端。

class Solution {
public:
    int maximumTop(vector<int>& nums, int k) {
        int n = nums.size();
        if(k == 0) return nums[0];
        if(n == 1 && k & 1) return -1;
        if(k == 1) return nums[1];
        int mx = 0;
        for(int i = 0; i < k - 1 && i < n; ++i){
            mx = max(mx, nums[i]);
        }
        if(k < n) mx = max(mx, nums[k]);
        return mx;
    }
};

Q4.得到要求路径的最小带权子图

用dijkstra找到每个点到终点、起点1、起点2的距离，然后一一判断即可。

class Solution {
    const long long INF = LONG_LONG_MAX / 3;
    using PLL = pair<long, long>;
public:
 
    int n;
 
	void dijkstra(int s, vector<long long> &d, vector<vector<PLL>> &g){
		priority_queue<PLL, vector<PLL>, greater<PLL>> q;
		for(int i = 0; i < n; ++i) d[i] = INF; //看下标从0开始还是从1开始
		d[s] = 0;  
		q.push({0, s});
		while(!q.empty()){
			int u = q.top().second;
            long long du = q.top().first;
    		q.pop();
    		if(du != d[u]) continue;
    		for(int i = 0; i < g[u].size(); ++i){
    			int v = g[u][i].second;
                long long dv = g[u][i].first;
    			if(d[v] > dv + du){
    				d[v] = dv + du;
    				q.push({d[v], v});
    			}
    		}
		}
	}
 
    long long minimumWeight(int n, vector<vector<int>>& edges, int src1, int src2, int dest) {
        this->n = n;
        long long ret = LONG_LONG_MAX;
        vector<long long> d0(n + 1, INF), d1(n + 1, INF), d2(n + 1, INF); // 数组大小要根据
    	vector<vector<PLL>> g(n + 1), rg(n + 1);
    	for(auto &i : edges){
    		g[i[0]].push_back({i[2], i[1]});
    		rg[i[1]].push_back({i[2], i[0]}); // 根据路径是单向还是双向来改 
    	}
    	dijkstra(dest, d0, rg);
        dijkstra(src1, d1, g);
        dijkstra(src2, d2, g);
        for(int i = 0; i < n; ++i){
            long long t = d1[i] + d2[i] + d0[i];
            if(t < ret) ret = t;
        }
        if(ret >= INF) return -1;
        return ret;
    }
};