为什么在 O(n) 时间复杂度代码上出现 Time Limit Exceeded 错误？

Question

问题https://leetcode.com/problems/first-missing-positive/ 提出：

给定一个未排序的整数数组 nums，返回最小的缺失正整数。

您必须实现一个在 O(n) 时间内运行并使用恒定额外空间的算法。

示例 1：

Input: nums = [1,2,0]
Output: 3
Example 2:

Input: nums = [3,4,-1,1]
Output: 2
Example 3:

Input: nums = [7,8,9,11,12]
Output: 1
 

Constraints:

1 <= nums.length <= 5 * 10**5
-2**31 <= nums[i] <= 2**31 - 1

因此我的代码满足了这一点：

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        nums=sorted(list(filter(lambda x: x>=0, nums)))
        nums= list(dict.fromkeys(nums))
        if 1 not in nums: return 1
        x=nums[0]
        for num in nums:
            if nums.index(num) != 0:
                dif = num - x
                if dif!=1:
                    return x + 1
                x=num
        return num+1
                
        

很高兴有人提供帮助。

Answer 1

正如 cmets 所述，sorted() 不需要线性时间。 sorted() 还会创建一个新列表，因此您的解决方案也违反了 O(1) 内存约束。

这是一个线性时间，恒定空间的解决方案。这个问题需要两件事（为简单起见，让n = len(nums)）：

1. 一种数据结构，可以在O(1)时间，判断区间[1, n]中的一个正整数是否在nums中。 （我们要检查n 数字，并且我们的算法的运行时间必须是线性的。）对于这个问题，我们的策略是创建一个表，使得对于介于 1 和n 之间的每个整数i，如果@ 987654331@ 是 nums，然后是 nums[i - 1] = i。 （答案必须是肯定的，并且答案不能大于n + 1——答案是n + 1 的唯一方法是nums 包含区间[1, n] 中的每个整数）。
2. 就地生成数据结构以满足内存限制的过程。

   这是一个解决方案。

   class Solution:
       def firstMissingPositive(self, nums: List[int]) -> int:
           # Match elements to their indicies.
           for index, num in enumerate(nums):
               num_to_place = num
               while num_to_place > 0 and num_to_place <= len(nums) and num_to_place != nums[num_to_place - 1]:
                   next_num_to_place = nums[num_to_place - 1]
                   nums[num_to_place - 1] = num_to_place
                   num_to_place = next_num_to_place
           
           # Find smallest number that doesn't exist in the array.
           for i in range(len(nums)):
               if nums[i] != i + 1:
                   return i + 1
           
           return len(nums) + 1
   

   两个for 循环都需要线性时间。第二个的原因很明显，但第一个的时间分析有点微妙：

   请注意，while 循环包含以下条件：num_to_place != nums[num_to_place - 1]。对于此while 循环的每次迭代，满足此条件的值的数量减少1。因此，此while 循环在所有迭代中最多只能执行n 次，这意味着第一个for 循环需要O(n) 时间。

Answer 2

# O(n) time and O(1) space
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
    index = 0
    while index < len(nums):
        if nums[index] > 0 and nums[index] - 1 < len(nums) and nums[index] != nums[nums[index] - 1]:
            nums[nums[index]-1], nums[index] = nums[index], nums[nums[index] - 1]
        else:
            index += 1
    
    for i, integer in enumerate(nums):
        if integer != i + 1:
            return i + 1
    return len(nums) + 1

Answer 3

# O(n) time and O(n) space
class Solution(object):
    def firstMissingPositive(self, nums):
        nums_set = set(nums)
        result = 1
        while True:
            if result not in nums_set:
                return result
            result += 1

# O(n) time and O(1) space
class Solution(object):
    def firstMissingPositive(self, nums):
    nums_length = len(nums)
    tmp = 0
    for i, num in enumerate(nums):
        while num <= nums_length and num > 0:
            tmp = nums[num-1]
            nums[num-1] = float('-inf')
            num = tmp
                
    for i in range(nums_length):
        if nums[i] != float('-inf'):
            return i + 1
        
    return len(nums) + 1