Leetcode Largest Divisible Subset

题意：给定一个集合，找到该集合的最大子集，使得该子集内的所有元素都可以相互整除。

思路：将元素排序，从最大的开始DFS。适当剪枝，当当前的集合已经大于剩下的集合就停止搜索。

class Solution {
public:
    vector<int> tempnums;
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        vector<int> re;
        if(nums.size() < 2) return nums;
        
        tempnums = nums;
        std::sort(tempnums.begin(), tempnums.end());
        
        vector<int>tempre;
        int maxsize = 0;
        for(int i = nums.size() - 1; i >= 0; -- i ) { //cout << i;
            dfs(i, tempre); //cout << tempre.size();
            if(maxsize < tempre.size()) { 
                maxsize = tempre.size();
                re = tempre;
                if(maxsize > nums.size() / 2 ) break;
            }
        }
        
        return re;
    }
    
    void dfs(int s, vector<int> &t) {
        vector<int> re;
        t = re;
        if(s < 1) {
            t.push_back(tempnums[s]);
            return;
        }
        
        int maxsize = 0;
        for(int i = s - 1; i >=0; i --) { //cout << i << s;
            if(tempnums[s] % tempnums[i] == 0 || tempnums[i] % tempnums[s] == 0) { //cout << "here" ;
                dfs(i, re); //cout << re.size();
                if(re.size() > maxsize) {
                    maxsize = re.size();
                    t = re;
                    if(maxsize > s / 2) break;
                }
            }
        }
        
        t.push_back(tempnums[s]);
        return;
    }
};

另一种思路是DP。排序后，从后向前遍历。复杂度为O(n^2)。

class Solution {
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        if(nums.size() < 2) return nums;
        std::sort(nums.begin(), nums.end());
        vector<int> dp(nums.size(), 0);
        vector<int> p;
        for(int i = 0; i < nums.size(); ++ i) p.push_back(i);
        
        int maxdp = -1;
        int po = -1;
        for(int i = nums.size() - 1; i >= 0; i --) {
            for(int j = i; j < nums.size(); j ++) {
                if(nums[j] % nums[i] == 0 && dp[i] < dp[j] + 1) {
                    dp[i] = dp[j] + 1;
                    p[i] = j;
                    if(maxdp < dp[i]) {
                        maxdp = dp[i];
                        po = i;
                    }
                }
            }
        }
        
        vector<int> re;
        int tempi = po;
        while(tempi != p[tempi]) {
            re.push_back(nums[tempi]);
            tempi = p[tempi];
        }
        re.push_back(nums[tempi]);
        
        return re;
    }
};