题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：中等
时间：-
tag：排序、动态规划

题目

给你一个由 无重复 正整数组成的集合 nums ，请你找出并返回其中最大的整除子集 answer ，子集中每一元素对 (answer[i], answer[j]) 都应当满足：
answer[i] % answer[j] == 0 ，或
answer[j] % answer[i] == 0
如果存在多个有效解子集，返回其中任何一个均可。

示例 1：

输入：nums = [1,2,3]
输出：[1,2]
解释：[1,3] 也会被视为正确答案。

示例 2：

输入：nums = [1,2,4,8]
输出：[1,2,4,8]

提示：
1 <= nums.length <= 1000
1 <= nums[i] <= 2 * 10⁹
nums 中的所有整数 互不相同

思路

动态规划

第一点：
a % b == 0 或 b % a == 0都能够被接受，那么若a > b
a % b 可能为0，但b % a一定不为0

那么，我们将数组【排序】之后，只要判断a（较大的数）是否整除b（较小的数）即可。

第二点：
若a % b == 0 && b % c==0 => a % c == 0

但是a % c == 0 && b % c == 0 ，不能得到a % b == 0

也就是说，%有【单向传递性】

那么其实这题就可以转换成我们之前非常熟悉的题目【最长上升子序列】。

为什么呢？不难发现其实>也有【单向传递性】

第三点：
这题不是求【上升子序列的长度】，而是求【上升子序列】。那么我们只需要一个额外的path数组，记录某个元素的上一个比他小的元素的位置（当前元素的上一个元素什么）（或者说，该元素的dp状态是从哪一个位置转移过来的）。

代码

class Solution {
    
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
    
        vector<int> ans;
        int n = nums.size();
        vector<int> dp(n,1);
        //上一个的路径
        vector<int> path(n,-1);
        //排序
        sort(nums.begin(),nums.end());
        //最大子集的终点指针
        int p = 0;
        //找出最大子集的值
        int maxAns = 0;
        /* * 如果a%b == 0 ，b%c == 0 ，那么 a%c == 0 （单向传递性） * 思路类似【最长上升子序列】 */
        for(int i=1;i<n;i++){
    
            for(int j=0;j<i;j++){
    
                if(nums[i] % nums[j] == 0){
    
                    if(dp[i] <= dp[j]){
    
                        dp[i] = dp[j]+1;
                        path[i] = j;
                    }
                }
                if(maxAns < dp[i]){
    
                    maxAns = dp[i];
                    p = i;
                }
            }
        }

        while(p != -1){
    
            ans.push_back(nums[p]);
            p = path[p];
        }
        return ans;
    }
};

算法复杂度

时间复杂度： O(n²)。排序时间为O(nlogn)。计算dp数组元素复杂度为O(n²)。
空间复杂度： O(n)。dp数组需要O(n)，path数组需要O(n)。