zoukankan      html  css  js  c++  java
  • LeetCode OJ 220.Contains Duplicate 3

    Given an array of integers, find out whether there are two distinct indices i and j in the array such that the difference between nums[i] and nums[j] is at most t and the difference between i and j is at most k.

    这个问题在前一个问题的基础上又对nums[i],nums[j]的关系作了约束,要求|nums[i]-nums[j]|<=t && |i-j|<=k;

    对于这个问题,在前面代码的基础上,一个很自然的做法是:

     1 public class Solution {
     2     public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
     3         Map<Integer,Integer> map = new HashMap<>(0);
     4         
     5         for(int i=0; i<nums.length; i++){
     6             for(int num : map.keySet()){
     7                 if(Math.abs(num-nums[i])<t && i-map.get(num)<k) return true;
     8             }
     9             map.put(nums[i],i);
    10             if(map.size()>k) map.remove(nums[i-k]);
    11         }
    12         return false;
    13     }
    14 }

    这是一个两层的循环,对于每一个nums[i],把它与Map中包含的其他所有元素进行比较,检查是否有满足条件的元素。这个方法很容易理解,但是时间复杂度太高,如果k很大的话,内层循环的迭代次数会很多。导致Time Limit Exceeded。

    如何才能对该算法进行改进呢?在参考了别人的代码后,发现了一个很机智的解法,它的时间复杂度是O(n),先把代码贴出来如下:

     1 public class Solution {
     2     public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
     3         if (t < 0) return false;
     4     Map<Long, Long> d = new HashMap<>();
     5     long w = (long)t + 1;
     6     for (int i = 0; i < nums.length; ++i) {
     7         long m = getID(nums[i], w);
     8         if (d.containsKey(m))
     9             return true;
    10         if (d.containsKey(m - 1) && Math.abs(nums[i] - d.get(m - 1)) < w)
    11             return true;
    12         if (d.containsKey(m + 1) && Math.abs(nums[i] - d.get(m + 1)) < w)
    13             return true;
    14         d.put(m, (long)nums[i]);
    15         if (i >= k) d.remove(getID(nums[i - k], w));
    16     }
    17     return false;
    18     }
    19     
    20     private long getID(long i, long w) {
    21     return i < 0 ? (i + 1) / w - 1 : i / w;
    22 }
    23 }

    接下来我们对该算法进行分析。首先我们来看下getID函数的功能。

    i>=0时,ID是i/w。举个例子,假设t=2,则w=3。如果nums[] = {0,1,2,3,4,5,6,7}。

    nums[0]/w = 0/3 = 0;

    nums[1]/w = 1/3 = 0;

    nums[2]/w = 2/3 = 0;

    nums[3]/w = 3/3 = 1;

    nums[4]/w = 4/3 = 1;

    nums[5]/w = 5/3 = 1;

    nums[6]/w = 6/3 = 2;

    这样就把nums[i]按照值的不同划分到了不同的组中。如果存在两个数|nums[i]-nums[j]|<=t,那么这两个数的ID或者相同,或者至多相差1。

    同样i<0时,ID是(i+1)/w - 1。同样假设w=3,nums[]={-6,-5,-4,-3,-2,-1}。

    nums[0]/w = (-6+1)/3 -1 = -3;

    nums[1]/w = (-5+1)/3 -1 = -3;

    nums[2]/w = (-4+1)/3 -1 = -2;

    nums[3]/w = (-3+1)/3 -1 = -2;

    nums[4]/w = (-2+1)/3 -1 = -2;

    nums[5]/w = (-1+1)/3 -1 = -1;

    这样就把nums[i]按照值的不同划分到了不同的组中。如果存在两个数|nums[i]-nums[j]|<=t,那么这两个数的ID或者相同,或者至多相差1。

    可以发现,这两个划分是连续的。ID=···-n,···,-1,0,1,···,n···。

    那么对于每一个nums[i],先计算它的ID,然后在Map中判断是否包含此ID,如果包含,那么肯定存在这样的两个数,他们之间的差小于等于t。否则的话判断是否存在与此ID相差为1的ID,即ID-1,ID+1。如果存在的话,判断两个数之间的差是否小于w(即小于等于t)。对于其他的ID,其实是没有必要来判断的。可以看到,提前计算ID的过程使得对于每一个nums[i],不需要像上一个算法中对Map中的每个数进行比较,而最多只需要进行三次比较即可判断出是否有满足条件的元素。

  • 相关阅读:
    linux系统cpu和内存占用率
    虚拟机网卡设置
    C语言中打印返回值
    MQTT_DEMO
    MQTT-C-UDP_PUB
    MQTT-C-PUB
    结构体指针用法
    linux系统如何操作隐藏文件
    mqtt学习笔记
    XML文件的读取----cElementTree
  • 原文地址:https://www.cnblogs.com/liujinhong/p/5378726.html
Copyright © 2011-2022 走看看