LeetCode No.368. Largest Divisible Subset

本文介绍了一种解决LeetCode上最大整除子集问题的算法，通过动态规划的方法找到给定数组中最长的子序列，使得序列中任意两个元素都能相互整除。文章详细解释了动态规划的应用过程，并提供了完整的参考代码。

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

Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies: Si % Sj = 0 or Sj % Si = 0.

If there are multiple solutions, return any subset is fine.

Example 1:

nums: [1,2,3]

Result: [1,2] (of course, [1,3] will also be ok)

Example 2:

nums: [1,2,4,8]

Result: [1,2,4,8]

===================================================================

题目链接：https://leetcode.com/problems/largest-divisible-subset/

题目大意：求出数组中最长非严格递增子序列，使得序列中任意相邻一对数值满足Si % Sj = 0 或者 Sj % Si = 0。

思路：动态规划，dp[i]记录nums[i]作为序列最后一位时的满足条件的最长子序列长度。

参考代码：

class Solution {
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        int n = nums.size() ;
        vector <int> ans ;
        if ( n == 0 )
            return ans ;
        sort ( nums.begin() , nums.end() ) ;//从小到大排序
        vector <int> pre ( n , 0 ) ;//记录序列前一个的下标
        vector <int> dp ( n , 0 ) ;//记录nums[i]个为序列最后一位时的序列长度
        pre[0] = 0 ;
        dp[0] = 1 ;
        for ( int i = 1 ; i < n ; i ++ )
        {
            int p = i , sum = 1 ;
            for ( int j = 0 ; j < i ; j ++ )//寻找最长序列并记录前一个下标
            {
                if ( nums[i] % nums[j] == 0 || nums[j] % nums[i] == 0 )
                {
                    if ( dp[j] + 1 > sum )
                    {
                        sum = dp[j] + 1 ;
                        p = j ;
                    }
                }
            }
            dp[i] = sum ;
            pre[i] = p ;
        }
        int as = 0 , temp = 0 ;
        for ( int i = 0 ; i < n ; i ++ )//找出最长序列最后一位下标
        {
            if ( dp[i] > as )
            {
                as = dp[i] ;
                temp = i ;
            }
        }
        while ( pre[temp] != temp ) //从后往前推，直到pre[temp] == temp说明到达序列第一位
        {
            ans.push_back ( nums[temp] ) ;
            temp = pre[temp] ;
        } 
        ans.push_back ( nums[temp] ) ;
        reverse ( ans.begin() , ans.end() ) ;//结果逆序
        return ans ;
    }
};