【LeetCode】1. Two Sum_针对leetcode中测试用例中超大数-CSDN博客

本文链接：https://blog.csdn.net/weixin_42344158/article/details/99708866

两种解法：

1. Brute force ——运行时间 $O(n^{2})$ ，内存开销 O(n)

遍历列表元素ele，再继续遍历查找列表中是否存在target-ele元素。返回两者的index。由于嵌套了遍历，时间开销比较大。

2. Hash table——运行时间 $O(n^{2})$ ，内存开销 O(n)

用哈希表能够快速查找的优势解决该问题。先建立空的哈希表，键为列表元素，值为该元素对应的index。遍历列表元素ele，若哈希表中存在target-ele，则返回两者的index，否则将键值对加入哈希表。如此一来只需要遍历一次列表即可。

Python源码：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        nums_dict = dict()
        for i, ele in enumerate(nums):
            if target - ele in nums_dict:
                return [i, nums_dict[target - ele]]
            else:
                nums_dict[ele] = i

我的心路：

因为想快速解决问题，所以首先采用brute force方法，结果在一个列表比较大的测试用例中超过了TimeLimit。过程中没有想到字典这一实现方式。由于可压缩的时间开销在查找target-ele这一步骤，为了加速查找，我想先将列表快速排序，再用二分法进行查找，这样时间开销将减轻至 O(nlog(n)) 。由于问题需要返回的是元素的index而非元素值，还需要保存一个index表与原列表对应，空间开销为 O(n) 。快速排序和二分法很久没有实现过，实现过程比较慢，浪费了很多时间。

但简单的Python实现了推荐方法也并非submission中的最优实现，只取得大约[25%，82%]的成绩，由于保存了一个字典，后者情有可原。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        index = [range(len(nums)]
        self.quickSort(nums, index, 0, len(nums) - 1)
        for i in range(len(nums)):
            j = self.find(target-nums[i], nums)
            if j != -1:
                return [index[i], index[j]]
        
    def quickSort(self, nums, index, first, last):
        if first >= last:
            return
        left = first
        right = last
        pivok = nums[first]
        pivok_index = index[first]
        while( left < right ):
            while( left < right and pivok <= nums[right] ):
                right -= 1
            nums[left] = nums[right]
            index[left] = index[right]
            while( left < right and nums[left] <= pivok):
                left += 1
            nums[right] = nums[left]
            index[right] = index[left]
        nums[left] = pivok
        index[left] = pivok_index
        self.quickSort(nums, index, first, left - 1)
        self.quickSort(nums, index, left + 1, last)
    
    def find(self, target, nums):
        left = 0
        right = len(nums) - 1
        if target == nums[left]:
            return left
        elif target == nums[right]:
            return right
        
        while left < right:
            middle = (left + right) // 2
            if nums[middle] > target:
                right = middle - 1
                if nums[right] == target:
                    return right
            elif nums[middle] < target:
                left = middle + 1
                if nums[left] == target:
                    return left
            elif nums[middle] == target:
                return middle
        return -1