四元组数据python:2种时间复杂度

题目

给一个包含n个数的整数数组S，在S中找到所有使得和为给定整数target的四元组(a, b, c, d)。

注意事项

四元组(a, b, c, d)中，需要满足a <= b <= c <= d

答案中不可以包含重复的四元组。

样例

例如，对于给定的整数数组S=[1, 0, -1, 0, -2, 2] 和 target=0. 满足要求的四元组集合为：

(-1, 0, 0, 1)

(-2, -1, 1, 2)

(-2, 0, 0, 2)

解题思路很简单，就是从一定长度的数组中找出四个元素的组合，并且使得这些组合中的元素的和为给定的值target即可
1、从n中取出m(n>m)的组合问题
2、所有的组合的筛选过滤和排序问题。

class Solution:
    def __init__(self):
        self.count = 0
        self.fourtuple_all = []

    """
    简单粗暴法：4层循环枚举
    时间复杂度达到O（n^4）
    """
    def fourSum_O4(self, numbers, target):
        # numbers = list(set(numbers)) # 去重 ,
        length = len(numbers)
        numbers.sort()
        for first_idx in range(length):
            first_num = numbers[first_idx]
            for second_idx in range(first_idx + 1, length):
                second_num = numbers[second_idx]
                for third_idx in range(second_idx + 1, length):
                    third_num = numbers[third_idx]
                    for fourth_idx in range(third_idx + 1, length):
                        fourth_num = numbers[fourth_idx]
                        fourtuple = [first_num, second_num, third_num, fourth_num]
                        if sum(fourtuple) == target and fourtuple not in self.fourtuple_all:
                            self.fourtuple_all.append(fourtuple)
                            self.count += 1
                            print('时间复杂度O(n^4)：第{}个四元组：{}'.format(self.count, fourtuple))
        print('***Processed!***')
        return self.fourtuple_all


    # O(n**3)
    """
    时间复杂度比较小的一种算法。 
    首先对数组进行排序，设置两个for循环，作为四个数中的前两个数。数据可去重可不去，数据数据不重复取即可。
    四个数中的后两个数怎么办，通过设置两个指针m和n,m从数组前往后进行遍历，n用来从数组后往前进行遍历。m>=n是结束循环的条件。
    遇到target==a+b+c+d的数就加到Arraylist中。
    """
    def fourSum_O3(self, numbers, target):
        # numbers = list(set(numbers)) # 去重 ,
        length = len(numbers)
        numbers.sort()
        for first_idx in range(length):
            for second_idx in range(first_idx+1, length):
                third_idx = second_idx+1
                fourth_idx = length-1
                while third_idx < fourth_idx:
                    counter = numbers[first_idx]+numbers[second_idx]+numbers[third_idx]+numbers[fourth_idx]
                    if counter == target:
                        fourtuple = [numbers[first_idx], numbers[second_idx], numbers[third_idx], numbers[fourth_idx]]
                        third_idx = third_idx+1
                        fourth_idx = fourth_idx-1
                        if fourtuple not in self.fourtuple_all:
                            self.fourtuple_all.append(fourtuple)
                            self.count += 1
                            print('时间复杂度O(n^3)：第{}个四元组：{}'.format(self.count, fourtuple))

                    elif counter < target:
                        third_idx = third_idx+1
                    elif counter > target:
                        fourth_idx = fourth_idx - 1
        print('***Processed!***')
        return self.fourtuple_all


def main():
    nums = [1, 0, -1, 0, -2, 2, -3, 3, -4, 4]
    target = 0

    Solution_Merge = Solution()
    fourtuple_all_Solution_O4 = Solution_Merge.fourSum_O4(nums, target)
    Solution_Merge = Solution()
    fourtuple_all_Solution_O3 = Solution_Merge.fourSum_O3(nums, target)

if __name__ == '__main__':
    main()

Result:

 

 

Reference:
1. 萌新刷题（七）四数之和