LeetCode每日一题4.6

368. 最大整除子集

问题分析

题目要求从一个无重复正整数组成的集合 nums 中，找出并返回其中最大的整除子集 answer。子集中任意两个元素对 (answer[i], answer[j]) 都应满足以下条件之一：
answer[i] % answer[j] == 0
answer[j] % answer[i] == 0
换句话说，子集中任意两个元素必须是倍数关系（即一个能整除另一个）。如果存在多个有效解集，返回其中任何一个均可。

思路

我们可以使用动态规划（DP）来解决这个问题：
排序：首先对输入数组 nums 进行升序排序。这样可以确保在遍历过程中，较小的数总是出现在较大的数之前。
动态规划数组：
定义一个数组 dp，其中 dp[i] 表示以 nums[i] 为结尾的最大整除子集的大小。
定义一个数组 prev，其中 prev[i] 表示 nums[i] 的前驱元素的索引，用于回溯构造最终的答案。
状态转移方程：
对于每个元素 nums[i]，遍历所有之前的元素 nums[j] (j < i)，如果 nums[i] % nums[j] == 0，说明 nums[i] 可以加入以 nums[j] 为结尾的子集。
更新 dp[i] = max(dp[i], dp[j] + 1)，同时记录前驱索引 prev[i] = j。
构造答案：
找到 dp 数组中的最大值，对应的索引即为最大整除子集的最后一个元素。
使用 prev 数组回溯，从后往前构造完整的子集。

代码

def largestDivisibleSubset(nums):
    if not nums:
        return []

    # 排序
    nums.sort()
    n = len(nums)

    # 初始化动态规划数组
    dp = [1] * n  # dp[i] 表示以 nums[i] 为结尾的最大整除子集的大小
    prev = [-1] * n  # prev[i] 表示 nums[i] 的前驱索引

    # 动态规划
    for i in range(n):
        for j in range(i):
            if nums[i] % nums[j] == 0 and dp[i] < dp[j] + 1:
                dp[i] = dp[j] + 1
                prev[i] = j

    # 找到最大整除子集的大小和对应的索引
    max_size = max(dp)
    max_index = dp.index(max_size)

    # 回溯构造答案
    answer = []
    while max_index != -1:
        answer.append(nums[max_index])
        max_index = prev[max_index]

    # 答案需要逆序输出
    answer.reverse()
    return answer

复杂度分析

时间复杂度：
排序的时间复杂度为 (O(n \log n))，其中 (n) 是数组的长度。动态规划部分的两层循环，时间复杂度为 (O(n^2))。
总时间复杂度为 (O(n^2))。
空间复杂度：
使用了两个辅助数组 dp 和 prev，空间复杂度为 (O(n))。

学习

排序：
将输入数组 nums 按升序排序，确保较小的数总是在较大的数之前。
动态规划数组初始化：
dp[i] 表示以 nums[i] 为结尾的最大整除子集的大小，初始值为 1（每个数本身就是一个子集）。
prev[i] 表示 nums[i] 的前驱索引，初始值为 -1（表示没有前驱）。
状态转移：
遍历每个元素 nums[i]，对于之前的每个元素 nums[j]，如果 nums[i] % nums[j] == 0，说明 nums[i] 可以加入以 nums[j] 为结尾的子集。
更新 dp[i] = max(dp[i], dp[j] + 1)，同时记录前驱索引 prev[i] = j。
找到最大子集：
找到 dp 数组中的最大值，对应的索引即为最大整除子集的最后一个元素。
回溯构造答案：
使用 prev 数组从后往前回溯，构造完整的子集。
最终答案需要逆序输出，因为回溯是从后往前的。
输入：nums = [1, 2, 3]
排序后：[1, 2, 3]
dp 数组：[1, 2, 2]（分别对应 [1], [1, 2], [1, 3]）
prev 数组：[-1, 0, 0]（2 的前驱是 1，3 的前驱是 1）
最大子集大小为 2，最后一个元素索引为 1 或 2。
构造答案：[1, 2] 或 [1, 3]。
输入：nums = [1, 2, 4, 8]
排序后：[1, 2, 4, 8]
dp 数组：[1, 2, 3, 4]（分别对应 [1], [1, 2], [1, 2, 4], [1, 2, 4, 8]）
prev 数组：[-1, 0, 1, 2]（2 的前驱是 1，4 的前驱是 2，8 的前驱是 4）
最大子集大小为 4，最后一个元素索引为 3。
构造答案：[1, 2, 4, 8]。