Update Solution3.java

Solution3.java

@@ -1,73 +1,55 @@
+package org.example;
+
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
-/**
- * @description:
- *
- * 给你一个由 无重复 正整数组成的集合 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 * 109
- * nums 中的所有整数 互不相同
- *
- */
-class Solution3 {
+public class Solution3 {
     public List<Integer> largestDivisibleSubset(int[] nums) {
-        int len = nums.length-1;
+        // 计算数组长度
+        int len = nums.length;
+        if (len == 0) return new ArrayList<>();
+
+        // 对数组进行排序
         Arrays.sort(nums);
 
-        // 第 1 步：动态规划找出最大子集的个数、最大子集中的最大整数
+        // 第 1 步：动态规划找最大子集的个数
         int[] dp = new int[len];
+        int[] prev = new int[len]; // 记录上一个数的索引
         Arrays.fill(dp, 1);
+        Arrays.fill(prev, -1); // 初始化前驱数组
         int maxSize = 1;
-        int maxVal = dp[0];
+        int maxValIndex = 0; // 存储最大子集的最后一个元素的索引
+
+        // 动态规划计算
         for (int i = 1; i < len; i++) {
-            for (int j = 1; j < i; j++) {
-                // 题目中说「没有重复元素」很重要
+            for (int j = 0; j < i; j++) {
+                // 检查整除条件
                 if (nums[i] % nums[j] == 0) {
-                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                    if (dp[i] < dp[j] + 1) {
+                        dp[i] = dp[j] + 1;
+                        prev[i] = j; // 记录链的前一个索引
+                    }
                 }
             }
-
+            // 更新最大子集的大小和对应的索引
             if (dp[i] > maxSize) {
                 maxSize = dp[i];
-                maxVal = i;
+                maxValIndex = i;
             }
         }
 
         // 第 2 步：倒推获得最大子集
-        List<Integer> res = new ArrayList<Integer>();
-        if (maxSize == 1) {
-            res.add(nums[0]);
-            return res;
+        List<Integer> res = new ArrayList<>();
+        for (int i = maxValIndex; i >= 0; ) {
+            res.add(nums[i]);
+            i = prev[i]; // 追踪到前驱元素
         }
 
-        for (int i = len - 1; i >= 0; i--) {
-            if (dp[i] == maxSize && maxVal % nums[i] == 0) {
-                res.add(nums[i]);
-                maxVal = nums[i];
-                maxSize--;
-            }
-        }
+        // 因为是从后向前添加的，反转结果
+        Collections.reverse(res);
         return res;
     }
 }
+