Leetcode编程实践 - 查找算法专题2

一. 知识点

1.1 xx

二. 查找算法的应用

1. 两数之和

A）题目描述

1. Two Sum

给出一个整型数组nums，返回这个数组中两个数字的索引值i和j，使得nums[i] + nums[j]等于一个给定的target值，两个索引不能相等。
如：nums= [2,7,11,15],target=9 返回[0,1]

B）思路

• 暴力解法：遍历两次数组，时间复杂度O(n^2)
• 为减少时间复杂度，先排序再双指针，时间复杂度O(nlogn)
• 考虑用空间换时间 -> 借用字典存储【元素值，所在索引】：
  遍历数组，记当前遍历到第i个位置
  • 若target - nums[i]在字典中，则找到了！
  • 否则，将num[i]作为key，i作为value存储在字典中

C）代码
时间复杂度O(n)，空间复杂度O(n)

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dic = {
   }
        for i in range(len(nums)):
            if target - nums[i] in dic:
                return [dic[target - nums[i]], i]
            dic[nums[i]] = i

---

219. 存在重复元素 II

A）题目描述

219. Contains Duplicate II

给出一个整形数组nums和一个整数k，是否存在索引i和j，使得nums[i]==nums[j]，且i和J之间的差不超过k。
示例1:
输入: nums = [1,2,3,1], k = 3
输出: true
示例 2:
输入: nums = [1,2,3,1,2,3], k = 2
输出: false

B）思路 & 代码

思路1 - 空间复杂度O(n)
类似两数之和的解法，辅助字典存储当前元素以及所在索引

时间复杂度O(n)，空间复杂度O(n)

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        dic = {
   }
        for i in range(len(nums)):
            if nums[i] in dic and i - dic[nums[i]] <= k:
                return True
            dic[nums[i]] = i
        return False

思路2 - 如何优化空间复杂度？
其实并不要字典存储每个元素的索引，只需维护一个长度为k的滑动数组
集合内部实现是dict，在in操作上是O(1)

时间复杂度O(n)，空间复杂度O(k)

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        record = set()
        for i in range(len(nums)):
            if nums[i] in record:
                return True
            record.add(nums[i])
            if len(record) > k:
                record.remove(nums[i-k])
        return False

---

220. 存在重复元素 III

A）题目描述

220. Contains Duplicate III

给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得nums [i] 和nums [j]的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。
示例 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

B）思路 &代码

必须加判断边界条件的，否则TLE
边界条件：若t == 0 and len(nums) == len(set(nums))，直接返回False即可

思路1 类似上题，维护一个长度为k的滑动数组

• 遍历数组，判断滑动数组，判断是否abs(num-nums[i]) <= t

时间复杂度O(nk)，空间复杂度O(k)

class Solution(object):
    def containsNearbyAlmostDuplicate(self, nums, k, t):
        """
        :type nums: List[int]
        :type k: int
        :type t: int
        :rtype: bool
        """
        if t == 0 and len(nums) == len(set(nums)):
            return False

        record = set()
        for i in range(len(nums)):
            for num in record:
                if abs(num-nums[i]) <= t:
                    return True
            record.add(nums[i])
            if len(record) > k:
                record.remove(nums[i-k])
        return False

思路2 - 也可在内部循环对record进行排序后二分

时间复杂度O(nk(logk)^2)，空间复杂度O(k)

思路3 - 暴力，注意内外层循环的取值范围

时间复杂度O(nk)，空间复杂度O(n)

class Solution(object):
    def containsNearbyAlmostDuplicate(self, nums, k, t):
        """
        :type nums: List[int]
        :type k: int
        :type t: int
        :rtype: bool
        """