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


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

题目描述

给你一个下标从 0 开始的整数数组 nums 和两个整数 key 和 k 。K 近邻下标 是 nums 中的一个下标 i ,并满足至少存在一个下标 j 使得 |i - j| <= k 且 nums[j] == key 。

以列表形式返回按 递增顺序 排序的所有 K 近邻下标。

示例 1:

输入:nums = [3,4,9,1,3,9,5], key = 9, k = 1
输出:[1,2,3,4,5,6]

解释:因此,nums[2] == key 且 nums[5] == key 。

对下标 0 ,|0 - 2| > k 且 |0 - 5| > k ,所以不存在 j 使得 |0 - j| <= k 且 nums[j] == key 。所以 0 不是一个 K 近邻下标。

对下标 1 ,|1 - 2| <= k 且 nums[2] == key ,所以 1 是一个 K 近邻下标。

对下标 2 ,|2 - 2| <= k 且 nums[2] == key ,所以 2 是一个 K 近邻下标。

对下标 3 ,|3 - 2| <= k 且 nums[2] == key ,所以 3 是一个 K 近邻下标。

对下标 4 ,|4 - 5| <= k 且 nums[5] == key ,所以 4 是一个 K 近邻下标。

对下标 5 ,|5 - 5| <= k 且 nums[5] == key ,所以 5 是一个 K 近邻下标。

对下标 6 ,|6 - 5| <= k 且 nums[5] == key ,所以 6 是一个 K 近邻下标。
因此,按递增顺序返回 [1,2,3,4,5,6] 。

暴力解法

一个数组 ans记录答案,一个hash 表记录已经插入过的索引,避免重复

基本思路:

一次遍历,如果找到与key值相等的元素,那么插入前后k个单位的索引值。

特殊情况1 : key值对应索引 前后k个单位 可能超出范围,需要进行修改

特殊情况2: key值对应索引 之间可能出现重复位,利用hash表进行记录

class Solution {
public:
    vector<int> findKDistantIndices(vector<int>& nums, int key, int k) {
        vector<int> ans;
        unordered_set<int> hashs;			// 避免重复
        
        for(int i = 0;i<nums.size();++i){
            if(nums[i] == key){
                int start = i-k < 0 ? 0 : i-k;                
                int end = i+k > nums.size()-1? nums.size()-1 : i+k;
                
                for(int j = start; j<= end;++j){
                    if(hashs.count(j)) continue;		// 如果重复直接跳过
                    hashs.insert(j);
                    ans.push_back(j);
                }
            }
        }
        
        return ans;
        
    }
};

优化1

以下思路借鉴了 大佬 daydayUppp 的双指针代码

如何去掉hash表 但同时又避免索引之间的重复

重复的原因就在于 内循环的起终点问题,如果起点取本次计算起点、上次终点 两者的最大值,那么是不是就有效避免了重复问题。

那么上述代码可以进行如下优化:

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

双指针

再进一步优化就是双指针了,把内循环的部分改为一个指针遍历,无非就是用j代替start。

class Solution {
public:
    vector<int> findKDistantIndices(vector<int>& nums, int key, int k) {
        vector<int> ans;
       	int j = 0;  // 指向一次内循环的起点。
        for(int i = 0;i<nums.size();++i){
            if(nums[i] == key){
                j = max(i-k,j);                
                for(j; j< min(i+k+1,(int)nums.size());++j){
                    ans.push_back(j);
                }
            }
        }
        
        return ans;
        
    }
};

文章作者: BeWater
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 BeWater !
评论
  目录