最大整除子集 [问题转换+排序+动规(面向前数组前部分)]

前言

一般的问题转换并不是很巧秒，基本都是找到题目问题的特点，将其翻译成有规律的/更数学味的语言，从而用代码实现。除此之外，问题转换+前置+后置操作型属于经典算法考察方式了。

一、最大整除子集

二、动态规划

1、空间动态起来（耗内存）

public class LargestDivisibleSubset {
    // 任意两个数都有整除关系，翻译过来就是这些数从小到大可形成倍数递推。（问题转换类型）
    // 找特点 + 排序 + 动态规划 + 空间动态起来 || 根据maxSize & 整除关系倒推。
    public List<Integer> largestDivisibleSubset(int[] nums) {
        // 前置操作--排序，便于后面倍数递推。
        Arrays.sort(nums);

        int[] max = new int[]{0,1};// 记录最大值的idx，以及该类集合的size.
        int[] f = new int[nums.length];// f[i] 表示前i个数能形成的最大倍数递推，面向前i个数组，区别于面向整个数组的完全背包问题。
        List<List<Integer>> arr = new ArrayList<>();

        for(int i = 0;i < nums.length;i++){
            f[i] = 1;
            // 不能new ArrayList<>(nums[i])，这不是传集合，是设定底层数组的大小。
            arr.add(Arrays.asList(nums[i]));
            for(int j = 0;j < i;j++){
                if(nums[i] % nums[j] == 0) {
                    if(f[i] < f[j] + 1) {

                        List<Integer> el = new ArrayList<>(arr.get(j));
                        el.add(nums[i]);
                        arr.set(i,el);

                        f[i] = f[j] + 1;
                    }
                }
            }
            if(f[i] > max[1]){
                max[0] = i;
                max[1] = f[i];
            }
        }
        return arr.get(max[0]);
    }
}

2、反向递推即可

// 动态空间太耗内存了，可以根据maxSize倒推。
class LargestDivisibleSubset2 {
    // 找特点 + 排序 + 动态规划 + 空间动态起来 || 根据maxSize & 整除关系倒推。
    public List<Integer> largestDivisibleSubset(int[] nums) {
        Arrays.sort(nums);

        int[] max = new int[]{0,1};
        int[] f = new int[nums.length];

        for(int i = 0;i < nums.length;i++){
            f[i] = 1;
            for(int j = 0;j < i;j++)
                if(nums[i] % nums[j] == 0 && f[i] < f[j] + 1) f[i] = f[j] + 1;

            if(f[i] > max[1]){
                max[0] = i;
                max[1] = f[i];
            }
        }
        // 倒推。
        List<Integer> rs = new ArrayList<>();
        for(int i = nums.length - 1;i >= 0 && max[1] > 0;i--)
            if(f[i] == max[1] && (rs.size() == 0 || rs.get(rs.size() - 1) % nums[i] == 0)) {
                rs.add(nums[i]);

                --max[1];
            }

        return rs;
    }
}

总结

1）一般的问题转换并不是很巧，基本都是找到题目问题的特点，将其翻译成有规律的/更数学味的语言，从而用代码实现。

2）动态规划前，还加了排序前置操作，且还需要问题转换，复杂性和未知性叠加！类似前置动规 + 后置dfs寻找类型问题。

3）该类动规属于面向数组的前部分，而不是像完全背包一样，每次递归面向整个数组。

参考文献

[1] LeetCode 最大整除子集