本文共 1809 字，大约阅读时间需要 6 分钟。

为了解决这个问题，我们需要找到给定正整数集合中的最大的整除子集。这个子集中的每一对元素必须满足其中一个能被另一个整除。

方法思路

我们可以使用动态规划来解决这个问题。以下是详细的步骤：

解决代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class LargestDivisibleSubset {
    public List
   
     largestDivisibleSubset(int[] nums) {
        List
    
      result = new ArrayList<>();
        if (nums.length == 0) {
            return result;
        }
        Arrays.sort(nums);
        int n = nums.length;
        int[] dp = new int[n];
        int[] index = new int[n];
        Arrays.fill(dp, 1);
        Arrays.fill(index, -1);
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] % nums[j] == 0) {
                    if (dp[j] + 1 > dp[i]) {
                        dp[i] = dp[j] + 1;
                        index[i] = j;
                    }
                }
            }
        }
        // Find the maximum value in dp array
        int max = 0;
        for (int i = 0; i < n; i++) {
            if (dp[i] > max) {
                max = dp[i];
            }
        }
        // Reconstruct the subset using the parent pointers
        int a = max;
        while (a != -1) {
            result.add(nums[a]);
            a = index[a];
        }
        return result;
    }
}
    
   

代码解释

• 排序数组：使用Arrays.sort(nums)对数组进行排序。
• 动态规划初始化：dp数组初始化为1，表示每个元素自身可以构成一个子集。index数组初始化为-1，表示初始时没有父节点。
• 填充dp数组：双重循环遍历数组，对于每个元素nums[i]，检查它是否能被前面每个元素nums[j]整除。如果能，更新dp[i]和index[i]以记录最长的子集路径。
• 构建结果子集：从最大的dp值开始，逆推回去，收集元素到结果列表中，构建最大的整除子集。

这个方法通过动态规划高效地找到最大的整除子集，时间复杂度为O(n^2)，适用于给定的约束条件。

转载地址：http://romq.baihongyu.com/