Leetcode 368. Largest Divisible Subset

最新推荐文章于 2024-02-10 00:39:46 发布

转载最新推荐文章于 2024-02-10 00:39:46 发布 · 171 阅读

Leetcode 同时被 2 个专栏收录

199 篇文章

订阅专栏

22 篇文章

订阅专栏

本文介绍了一种求解最大整除子集问题的算法，该算法通过动态规划思想找到数组中最大的整数子集，使得子集中的任意两个元素都能相互整除。通过排序原数组减少时间复杂度至O(n^2)，并使用辅助数组记录最优解路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * similar with the Longest Increasing Subsequence (LIS)
 * let l[i] to be the largest divisible subset ending at index i
 * to determine l[i+1] we need to do,
 *  i. for every list l[j] in l[1] through l[i]
 *        if for every element in l[j], nums[i+1]%l[j]==0 or l[j]%nums[i+1]==0
 *           then add nums[i+1] to the end of l[j]
 *        else no need to change l[j]
 *  ii. if l[i+1].size < l[j].size, l[i+1].size = l[j].size
 * 
 *  time complexity O(n^3)
 *  however, if we sort the orginal array, then we don't need the inner for loop
 */ 
public class Solution {
    public List<Integer> largestDivisibleSubset(int[] nums) {
        List<Integer> result = new ArrayList<Integer>();
        if(nums==null||nums.length==0)
            return result;
     
        Arrays.sort(nums);
     
        int[] t = new int[nums.length];
        int[] index = new int[nums.length];
        Arrays.fill(t, 1);
        Arrays.fill(index, -1);
     
        int max=0;
        int maxIndex=-1;
     
        for(int i=0; i<t.length; i++){
            for(int j=i-1; j>=0; j--){
                if(nums[i]%nums[j]==0 && t[j]+1>t[i]){
                    t[i]=t[j]+1;
                    index[i]=j;
                }
            }
     
            if(max<t[i]){
                max=t[i];
                maxIndex=i;
            }
        }
     
        int i=maxIndex;
        while(i>=0){
            result.add(nums[i]);
            i=index[i];
        }
     
        return result;
    }
}