leetcode 220. 存在重复元素 III

题目 220. 存在重复元素 III

存在重复元素 III

给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j,使得 abs(nums[i] - nums[j]) <= t ,同时又满足 abs(i - j) <= k 。

如果存在则返回 true,不存在返回 false。

示例 1:

输入:nums = [1,2,3,1], k = 3, t = 0
输出:true

示例 2:

输入:nums = [1,0,1,1], k = 1, t = 2
输出:true

示例3:

输入:nums = [1,5,9,1,5,9], k = 2, t = 3
输出:false

提示:

  • 0 <= nums.length <= 2 * 10^4
  • -2^31 <= nums[i] <= 2^31 - 1
  • 0 <= k <= 10^4
  • 0 <= t <= 2^31 - 1

方法一 :滑动窗口 + 有序集合
1、由于abs(i - j) <= k ,可以基于滑动窗口的思想,利用set存储k个元素
2、在添加新元素nums[ i ]之前,用二分找到第一个大于等于nums[ i ] - t 的元素
3、二分查找到的元素 x 可能出现在三个范围之间,

  • nums[ i ] - t < x <= nums[ i ]
  • nums[ i ] < x <= nums[ i ] + t
  • nums[ i ] + t < x
    只要属于[nums[ i ] - t , nums[ i ] + t ]该区间即可
    所以只要 x <= nums[ i ] + t 即可返回 true
class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        int n = nums.size();
        set<long> set;
        for(int i=0; i<n; i++){
            //lower_bound(x)二分查找返回>= x 的最小数字的位置
            auto it = set.lower_bound((long)nums[i] - t);
            if(it != set.end() && *it - nums[i] <= t){
                return true;
            }
            set.insert(nums[i]);
            //达到窗口大小,删除最左侧的元素
            if(i >= k){
                set.erase(nums[i - k]);
            }
        }
        return false;
    }
};

如果用int,为了避免溢出,需要稍微处理,如下:

  • max(nums[ i ] , INT_MIN + t) - t ,由于-2^31 <= nums[i] <= 2^31 - 1, 所以nums[ i ] - t 存在溢出风险,假如nums[ i ] - t 下溢出,这步操作可以使下限变为INT_MIN, 也就是 x 的左边界变大 为 INT_MIN

同样道理

  • min(nums[i], INT_MAX - t) + t由于-2^31 <= nums[i] <= 2^31 - 1, 所以nums[ i ] + t 存在溢出风险,假如nums[ i ] + t 上溢出,这步操作可以使上限变为INT_MAX, 也就是 x 的右边界变小 为 INT_MAX
class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        int n = nums.size();
        set<int> set;
        for(int i=0; i<n; i++){
            //lower_bound(x)二分查找返回>= x 的最小数字的位置
            auto it = set.lower_bound(max(nums[i], INT_MIN + t) - t);
                               //这部分只需判断*it是否大于nums[i] + t;
            if(it != set.end() && *it <= min(nums[i], INT_MAX - t) + t){
                return true;
            }
            set.insert(nums[i]);
            if(i >= k){
                set.erase(nums[i - k]);
            }
        }
        return false;
    }
};

方法二:桶
按照元素的大小进行分桶
由于abs(nums[i] - nums[j]) <= t,所以只要两个数的差值 <= t 即可,
我们可以设定桶的大小为 t + 1。(例如,整数,对于闭区间[a, b], 元素个数为 b - a + 1,这个桶的大小代表一定区间的元素个数)。

  • 如果两个元素同属一个桶,那么这两个元素必然符合条件
  • 如果两个元素属于相邻桶,那么我们需要校验这两个元素是否差值不超过 t。
  • 如果两个元素既不属于同一个桶,也不属于相邻桶,那么这两个元素必然不符合条件。

官方题解 中的 分桶:当 x >= 0 时,例如 当 t = 9,桶的大小是10, 非负数是0 ~ 9,10~19…这种为一组,自然而然分别被分到0, 1, …桶。
而负数是-1 ~ -10 , -11 ~ -20…这些是一组,按理说应该分别被分到 - 1 , -2, …桶。 而许多语言整除时是向下取整的,如果-1~-10直接除以10,会被分到0 和 - 1两组中,而不是- 1 这一组, 所以先+1变成-0~-9,与正数一致,再除以10,最后减1,
正好是 -1 这一组

class Solution {
public:
    //分桶,获得桶id
    int getId(long x, long t){
        if(x >= 0) {
            return x / (t + 1);
        }
        else{
            return (x + 1) / (t + 1) - 1;
        }
        return 0;
    }

    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        int n = nums.size();
        unordered_map<int, int> map;
        for(int i=0; i<n; i++){
            long x = nums[i];   //当前元素
            int id = getId(x, t);
            //位于同一个桶
            if(map.count(id)) return true;
            //相邻左侧桶
            if(map.count(id - 1) && abs(x - map[id - 1]) <= t){
                return true;
            }
            //相邻右侧桶
            if(map.count(id + 1) && abs(x - map[id + 1]) <= t){
                return true;
            }
            map[id] = nums[i];  //进桶
            if(i >= k){
                //删除nums[i - k] 元素所在的桶
                map.erase(getId(nums[i - k], t));
            }
        }
        return false;
    }
};

(这么秒的桶,赶紧记下来)

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值