題目

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:

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

Example 2:

Input: [1,2,4,8]
Output: [1,2,4,8]

分析

這道題很明顯應該用動態規劃的方法來求解。

首先我們要將原問題劃分為子問題，且子問題的規模是從小到大的。所以我們將原問題劃分為以下子問題：首先將原來的輸入陣列 nums 按照從小到大的順序排序，然後遍歷陣列 nums，每次遍歷求出以 nums[i](i = 0~len-1) 為結尾的 Largest Divisible Subset，並把每次便歷得到的結果存入 result[i](i = 0~len-1)。注意，如果每次遍歷求出以 nums[i](i = 0~len-1) 為開頭的 Largest Divisible Subset，子問題的規模是從大到小的，那麼我們一開始就要求規模較大的子問題，這樣子是求不出結果的，也是不符合動態規劃的思想的。

然後我們要確定子問題之間的關係。當我們求以 nums[i](i = 0~len-1) 為結尾的 Largest Divisible Subset 時，我們要在 nums[i] 之前的陣列部分找到符合原題關係的陣列子集，即找到符合的 result[j](j = 0~i-1)，並選擇一個數組長度最大的 result[j](j = 0~i-1)，與 nums[i] 合併為result[i]，成為以 nums[i](i = 0~len-1) 為結尾的 Largest Divisible Subset。這樣不斷進行下去，所有的以 nums[i](i = 0~len-1) 為結尾的 Largest Divisible Subset都找到了，並都存在result[i](i = 0~len-1)中。

最後，遍歷result[i](i = 0~len-1)，找出一個數組長度最長的作為返回值，即最終結果。

示例

以輸入陣列{2, 3, 4, 9, 8}為例：

首先排序得到{2, 3, 4, 8, 9}，然後開始遍歷陣列

以2為結尾的Largest Divisible Subset只有2本身，result[0] = {2}；

以3為結尾的Largest Divisible Subset只有3本身，result[1] = {3}；

以4為結尾的Largest Divisible Subset，4之前的陣列部分有且只有一個符合的result[0]，result[2] = {2, 4}；

以8為結尾的Largest Divisible Subset，8之前的陣列部分有符合的result[0]和result[2]，選擇更大的result[2]，所以result[3] = {2, 4, 8}；

以9為結尾的Largest Divisible Subset，9之前的陣列部分有且只有一個符合的result[1]，result[4] = {3, 9}；

最終返回最大的result[3]

程式碼

class Solution {
public:
   bool isArrayCorrect(vector<int> arr, int num) {
        int i;
        for (i = 0; i < arr.size(); i++) {
            if (! (arr[i] % num == 0 || num % arr[i] == 0)) {
                break;
            }
        }
        if (i == arr.size()) {
            return true;
        }
        else {
            return false;
        }
    }

    vector<int> largestDivisibleSubset(vector<int>& nums) {
        int len = nums.size();

        if (len == 0) {
            return {};
        }

        int maxlen = 0;
        int maxPosition = -1;

        vector<vector<int>> result(len);

        sort(nums.begin(), nums.end());

        result[0].push_back(nums[0]);
        for (int i = 1; i < len; i++) {
            int subPosition = -1;
            int subMaxLen = 0;
            for (int j = 0; j < i; j++) {
                if (isArrayCorrect(result[j], nums[i])) {
                    if (result[j].size() > subMaxLen) {
                        subMaxLen = result[j].size();
                        subPosition = j;
                    }
                }
            }
            if (subPosition == -1) {
                result[i].clear();
                result[i].push_back(nums[i]);
            }
            else {
                result[i].clear();
                result[i].assign(result[subPosition].begin(), result[subPosition].end());
                result[i].push_back(nums[i]);
            }

        }
 
        for (int i = 0; i < len; i++) {
            if (result[i].size() > maxlen) {
                maxPosition = i;
                maxlen = result[i].size();
            }
        }
        return result[maxPosition];

    }
};