动态规划 on Coder_Studio

BISHI103 【模板】有依赖的背包问题

Tue, 10 Mar 2026 20:41:45 +0000

思路

求解代码

// 存储并查集中节点 i 的父节点
    private static int[] parent;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价钱
    private static int[] cost;
    // 存储第 i 朵云（或合并后以 i 为根的商品组）的总价值
    private static int[] value;

    public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 1. 读取基础配置：n 朵云, m 个搭配关系, w 现有的钱
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);
        int m = Integer.parseInt(strA[1]);
        int w = Integer.parseInt(strA[2]);

        parent = new int[n + 1];
        cost = new int[n + 1];
        value = new int[n + 1];

        // 2. 初始化每朵云的属性，并初始化并查集（每个节点初始父节点为自己）
        for (int i = 1; i <= n; i++) {
            String[] strB = br.readLine().trim().split("\\s+");
            cost[i] = Integer.parseInt(strB[0]);
            value[i] = Integer.parseInt(strB[1]);
            parent[i] = i;
        }

        // 3. 处理搭配购买关系：使用并查集将必须一起买的云“联通”起来
        for (int i = 0; i < m; i++) {
            String[] strC = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(strC[0]);
            int v = Integer.parseInt(strC[1]);
            union(u, v);
        }

        // 4.将同一集合内所有云的价钱和价值全部累加到该集合的“根节点”上
        for (int i = 1; i <= n; i++) {
            int root = find(i);
            // 如果当前节点不是根节点，则将其属性转移给根节点
            if (root != i) {
                cost[root] += cost[i];
                value[root] += value[i];
                // 清空当前非根节点的属性，防止在后续背包计算中被重复统计
                cost[i] = 0;
                value[i] = 0;
            }
        }

        // 5. 执行 0/1 背包算法
        // dp[j] 表示在花费 j 元钱的情况下能获得的最大价值
        int[] dp = new int[w + 1];
        for (int i = 1; i <= n; i++) {
            // 只处理根节点（代表一个完整的“捆绑商品组”）
            if (parent[i] == i) {
                // 0/1 背包内层循环必须“逆序遍历”，防止同一商品被多次购买
                for (int j = w; j >= cost[i]; j--) {
                    // 状态转移方程：不买当前组 vs 买当前组（消耗钱，加价值）
                    dp[j] = Math.max(dp[j], dp[j - cost[i]] + value[i]);
                }
            }
        }

        // 6. 输出预算 w 内能获得的最大总价值
        out.println(dp[w]);

        // 刷新缓冲区并释放资源
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 查找根节点（带路径压缩优化）
     */
    private static int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        // 将查找路径上的所有节点直接挂在根节点下，加速后续查找
        return parent[i] = find(parent[i]);
    }

    /**
     * 合并两个集合
     */
    private static void union(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI != rootJ) {
            // 将 I 树合并到 J 树下
            parent[rootI] = rootJ;
        }
    }

动态规划-买卖股票的最好时机I-II-III

Sun, 25 Jan 2026 00:04:30 +0000

求解代码

public int maxProfit (int[] prices) {
        if(prices==null||prices.length<2){
            return 0;
        }

        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0]=0;
        dp[0][1]=-prices[0];
        for(int i=1;i<n;i++){
            dp[i][0]=Math.max(dp[i-1][0], dp[i-1][1]+prices[i]);
            dp[i][1]=Math.max(dp[i-1][1],-prices[i]);
        }
        return dp[n-1][0];
    }

求解代码

public int maxProfit(int[] prices) {
        if ( prices == null || prices.length < 2 ) {
            return 0;
        }

        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[n - 1][0];
    }

小贴士

和上面的类型（一）不一样的是，这题可以进行多次交易，代码上的体现就是：

求解代码

public int maxProfit(int[] prices) {
        return maxProfit_k(prices, 2);
    }

    public int maxProfit_k(int[] prices, int k) {
        if (prices == null || prices.length < 2) {
            return 0;
        }

        int n = prices.length;
        int[][][] dp = new int[n][k + 1][2];
        for (int j = 0; j <= k; j++) {
            dp[0][j][0] = 0;
            dp[0][j][1] = -prices[0];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);
                dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);
            }

        }
        return dp[n - 1][k][0];
    }

小贴士

说说三维DP的定义：

dp[i][j][0]：第i天，最多完成了j次交易，不持有股票的最大利润；

dp[i][j][1]：第i天，最多完成了j次交易，持有股票的最大利润；

动态规划-打家劫舍I-II

Sat, 24 Jan 2026 23:49:36 +0000

求解代码

public int rob (int[] nums){
        int[] memo = new int[nums.length+1];
        Arrays.fill(memo, -1);
        return dp(nums,0, memo);
    }

    private int dp(int[] nums,int start,int[] memo){
        if(start>=nums.length){
            return 0;
        }

        if(memo[start]!=-1){
            return memo[start];
        }
        int ans = Math.max(dp(nums, start+1,memo),nums[start]+dp(nums, start+2,memo));
        memo[start]= ans;
        return ans;
    }

小贴士

记忆化存储+自顶向下

求解代码

public int rob(int[] nums) {
        int n = nums.length;
        int[] memo1 = new int[n + 1];
        int[] memo2 = new int[n + 1];
        Arrays.fill(memo1, -1);
        Arrays.fill(memo2, -1);
        int case1 = dp(nums, 0, n - 2, memo1);
        int case2 = dp(nums, 1, n - 1, memo2);
        return Math.max(case1, case2);
    }

    private int dp(int[] nums, int start, int end, int[] memo) {
        if (start > end) {
            return 0;
        }

        if (memo[start] != -1) {
            return memo[start];
        }
        int ans = Math.max(dp(nums, start + 1, end, memo), nums[start] + dp(nums,
                start + 2, end, memo));
        memo[start] = ans;
        return ans;
    }

小贴士

现在的情况是第一房间和最后一个房间也相当于是相邻的，不能同时抢。

那么，首尾房间不能同时被抢，只可能有三种不同情况：

都不被抢
第一个房间被抢最后一间不抢
最后一个房间被抢第一间不抢

不过，本题不需要三种情况都进行比较，因为房间里的钱数都是非负数，后两种情况对于房间的选择余地肯定比情况一大，所以只要比较情况二和情况三就行了。

代码也可以在【打家劫舍I】的【自顶向下+记忆化存储】基础上进行修改。

需要注意的是独立的子问题必须使用独立的记忆化缓存，不能共用，不然会造成缓存被覆盖的问题，所以这里需要使用两个memory。

动态规划-最长的括号子串

Sat, 24 Jan 2026 20:48:47 +0000

求解代码

public int longestValidParentheses(String s) {
        char[] str = s.toCharArray();
        int[] dp = new int[str.length];
        int ans = 0;
        for (int i = 1, p; i = 0 && str[p] == '(') {
                    dp[i] = dp[i - 1] + 2 + (p - 1 >= 0 ? dp[p - 1] : 0);
                }
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }

小贴士

dp[i]是以字符串中第i个字符str[i]结尾的最长有效括号子串的长度。

因为有效括号子串一定是以)结尾到，以(结尾的子串不可能有效。

所以，只需要处理str[i] == ')'的情况，str[i] == '('时，让dp [i] = 0 即可。

根据定义dp[i-1]表示的是以str[i-1]结尾的最长有效括号长度，也就是说从i-dp[i-1]到i-1的这段子串是有效括号。

那么，要匹配当前的这个str[i] = ')'，左括号必须出现在从i-dp[i-1]到i-1的这段有效子串的前一个位置，这个位置就是p，即i - dp[i-1] - 1。

p指的是当前)能形成有效匹配的唯一可能的左括号位置。

状态转移方程的含义是：

以i结尾的最长有效长度 = 前一个位置(i-1)的有效长度 + 当前匹配的一对括号 + 左括号位置(p)左边（如果有）的有效长度。

动态规划-正则表达式匹配

Fri, 23 Jan 2026 23:42:18 +0000

求解代码

public boolean match (String str, String pattern) {
        int m = str.length();
        int n = pattern.length();

        boolean[][] dp = new boolean[m+1][n+1];

        for(int i=0;i0&&(str.charAt(i-1)==pattern.charAt(j-1)||pattern.charAt(j-1)=='.')){
                            dp[i][j]=dp[i-1][j-1];
                        }
                    }else{
                        if(j>=2){
                            dp[i][j]|=dp[i][j-2];
                        }

                        if(i>=1&&j>=2&&(str.charAt(i-1)==pattern.charAt(j-2)||pattern.charAt(j-2)=='.')){
                            dp[i][j]|=dp[i-1][j];
                        }
                    }
                }
            }               
        }
        return dp[m][n];
    }

小贴士

DP这个boolean数组，dp[i][j]的意思是str的前i个字符和pattern的前j个字符，能否匹配成功。

这里的DP数组，考虑了下标0位置的空字符串，所以为了存储整个字符串，DP数组长度需要+1。

这里没有像编辑距离那题一样单独处理初始化逻辑，而是在嵌套for循环的逻辑中处理的，这样代码会更简洁一些。

这里有个细节需要注意一下就是，dp[i][j]是前i/j个字符，所以pattern的第j个字符对应原字符串的下标为j-1的字符，其实和【编辑距离】的下标转换是一样的。

当pattern非空的时候，大范围是考虑了pattern[j-1]是否为*两种情况。

1.当pattern[j-1]不是*时，如果str非空并且和str[j-1]相对或者pattern[j-1]直接是.的话，说明匹配成功。

2.当pattern[j-1]是*的话，就需要考虑是零次匹配前面的字符还是匹配多次前面的字符的问题了。

因为pattern[j-1]是*，所以pattern[j-2]就是*的前驱字符，那处理这类情况就应该着重看看pattern[j-2]了。

如果是匹配0次前驱字符，那pattern的j-2和j-1位都可以舍弃，此时要判断str前i个和pattern前j个是否匹配，等价于判断str前i个和pattern前j-2个是否匹配。
如果是匹配了多次前驱字符，那就让pattern保持不动，让str的前i-1个字符和pattern的前j个字符继续匹配。

【动态规划】BM75 编辑距离(一)

Fri, 23 Jan 2026 19:50:03 +0000

求解代码

public int editDistance(String str1, String str2) {
        int m = str1.length();
        int n = str2.length();
        int[][] dp = new int[m + 1][n + 1];

        for (int i = 0; i <= m; i++) {
            dp[i][0] = i;
        }

        for (int j = 0; j <= n; j++) {
            dp[0][j] = j;
        }

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                }

            }
        }
        return dp[m][n];
    }

小贴士

1.dp[i][j]的意思是将str1的前i个字符转换为str2的前j个字符，所需要的最小编辑距离。至于为什么要加1，是因为这里考虑了下标为0位置代表的空字符串，也就是DP的边界条件。单独拎出来的那两个for循环，处理的是把空字符串转成str2的前j个字符需要j次插入操作，以及把str1的前i个字符转成空字符串需要i次删除操作。

2.下面的两个for循环嵌套，是把str1的前m个字符转成str2的前n个字符，这里charAt方法是i-1主要是因为第i个字符对应的下标是i-1。

动态规划-最长回文子串

Thu, 22 Jan 2026 21:06:15 +0000

求解代码

public int getLongestPalindrome (String A) {
        if(A==null||A.length()==0){
            return 0;
        }

        int n = A.length();
        char[] str = A.toCharArray();

        int max = 1;
        boolean[][] dp = new boolean[n][n];
        for(int i=0;i<n;i++){
            dp[i][i]=true;
        }

        for(int i=1;i<n;i++){
            for(int j=0;j<i;j++){
                if(str[i]!=str[j]){
                    dp[j][i]=false;
                }else{
                    if(i-j<=1){
                        dp[j][i]=true;
                    }else{
                        dp[j][i]=dp[j+1][i-1];
                    }

                    if(dp[j][i]){
                        max=Math.max(max, i-j+1);
                    }
                }
            }
        }
        return max;
    }

小贴士

1.dp[j][i] 表示子串 A[j..i]（闭区间）是否为回文，必须保证 j ≤ i

判断规则：

首尾不等 → 非回文
首尾相等 + 长度≤2 → 必回文
首尾相等 + 长度 > 2 → 看中间子串是否回文

【动态规划】连续子数组的最大和

Wed, 21 Jan 2026 21:15:37 +0000

求解代码

public int FindGreatestSumOfSubArray(int[] array) {
        int sum = 0;
        int max = array[0];
        for(int i=0;i<array.length;i++){
            sum= Math.max(array[i],sum+array[i]);

            max=Math.max(max, sum);
        }

        return max;
    }

小贴士

这题和前文【动态规划】最长上升子序列（一）有些类似，不同的是本题是连续子数组，常规思路的话我们需要利用dp，dp[i] 代表示以元素 array[i] 为结尾的连续子数组最大和。

不难想到，状态转移方程： dp[i] = Math.max(dp[i-1]+array[i], array[i])

这里我们为了进一步简化动态规划，使用一个变量sum来表示当前连续的子数组和。

【动态规划】最长上升子序列（一）

Wed, 21 Jan 2026 20:08:09 +0000

求解代码

        public int LIS(int[] arr) {
        if(arr==null||arr.length==0){
            return 0;
        }

        int[] dp = new int[arr.length];
        Arrays.fill(dp, 1);
        int ans = 1;

        for(int i=1;i<arr.length;i++){
            for(int j=0;j<i;j++){
                if(arr[i]>arr[j]){
                    dp[i]=Math.max(dp[j]+1, dp[i]);
                }
                
            }
            ans = Math.max(ans,dp[i]);
        }
        return ans;
    }

小贴士

状态转移：dp[i] = 前j个的最长长度+1 和当前dp[i]的最大值

【动态规划】兑换零钱（一）

Tue, 20 Jan 2026 23:37:19 +0000

求解代码

public int minMoney (int[] arr, int aim) {
        int[] dp = new int[aim+1];
        Arrays.fill(dp, Integer.MAX_VALUE);

        dp[0]=0;

        for(int i=0;i<arr.length;i++){
            for(int j=arr[i];j<=aim;j++){
                if(dp[j-arr[i]]!=Integer.MAX_VALUE){
                    dp[j]=Math.min(dp[j-arr[i]]+1,dp[j]);
                }
                
            }
        }

        return dp[aim]==Integer.MAX_VALUE?-1:dp[aim];
    }

小贴士

dp[j] 表示的是凑出金额j所需的最少硬币数

【迭代+动态规划】把数字翻译成字符串

Tue, 20 Jan 2026 22:24:51 +0000

求解代码

    public int solve(String nums) {
        
        if (nums == null || nums.length() == 0 || nums.charAt(0) == '0') {
            return 0;
        }

        int n = nums.length();
        
        int prevPrev = 1; 
        int prev = 1;

        for (int i = 2; i <= n; i++) {
            int curr = 0;
            char currChar = nums.charAt(i - 1);
            char prevChar = nums.charAt(i - 2);

            
            if (currChar != '0') {
                curr += prev;
            }

            
            int twoDigit = Integer.parseInt(nums.substring(i - 2, i));
            if (twoDigit >= 10 && twoDigit <= 26) {
                curr += prevPrev;
            }

            
            prevPrev = prev;
            prev = curr;
        }

        return prev;
    }

小贴士

变量	对应传统DP数组	通俗含义
`prevPrev`	`dp[i-2]`	前`i-2`个字符的解码方式数
`prev`	`dp[i-1]`	前`i-1`个字符的解码方式数
`curr`	`dp[i]`	临时变量，存储「前`i`个字符」的解码方式数

int prevPrev = 1 对应dp[0]=1，也就是空字符串的解码方式数，没有实际解码意义，只为让组合解码的计算成立（类似于乘法中的 “1”）

【从下至上+动态规划】矩阵的最小路径和

Tue, 20 Jan 2026 21:07:31 +0000

求解代码

public int minPathSum(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;

        int[][] dp = new int[m][n];
        dp[0][0] = matrix[0][0];

        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + matrix[i][0];
        }

        for (int j = 1; j < n; j++) {
            dp[0][j] = dp[0][j - 1] + matrix[0][j];
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + matrix[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }

小贴士

代码结构跟上一篇【至下而上+动态规划】不同路径的数目（一）是一样的。

dp[i][j] 的定义：从起点 (0,0) 走到位置 (i,j) 的最小路径和。

动态规划-不同路径的数目

Tue, 20 Jan 2026 00:51:24 +0000

求解代码

public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];

        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }

        for (int j = 0; j < n; j++) {
            dp[0][j] = 1;
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }

小贴士

因为只能从上面或左边走过来，所以递推公式是 dp[i][j]=dp[i-1][j]+dp[i][j-1]；

同时，也不难得出第一行和第一列都是1的边界条件。

动态规划-字符串-最长公共子系列二

Tue, 20 Jan 2026 00:50:32 +0000

求解代码

public String LCS(String s1, String s2) {
    if(s1==null||s2==null||s1.length()==0||s2.length()==0){
        return "-1";
    }

    int m = s1.length();
    int n = s2.length();
    String[][] dp = new String[m+1][n+1];
    
    // 把所有dp[0][j] 和 dp[i][0] 赋值为空字符串 ""，解决null问题
    for(int i=0;i<=m;i++){
        dp[i][0] = "";
    }
    for(int j=0;j<=n;j++){
        dp[0][j] = "";
    }

    
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            if(s1.charAt(i-1)==s2.charAt(j-1)){
                dp[i][j]=dp[i-1][j-1]+s1.charAt(i-1);
            }else{
                String temp1String = dp[i-1][j];
                String temp2String = dp[i][j-1];
                dp[i][j]=temp1String.length()>temp2String.length()?temp1String:temp2String;
            }
        }
    }
    
    String res = dp[m][n];
    return res.length()>0 ? res : "-1";
}

小贴士

dp数组会取到边界m和n，所以定义长度时需要加1。

动态规划-最长公共子串

Tue, 20 Jan 2026 00:35:35 +0000

求解代码

public String LCS(String str1, String str2) {
        if(str1==null||str2==null||str1.length()==0||str2.length()==0){
            return null;
        }

        int m = str1.length();
        int n = str2.length();

        String[][] dp = new String[m+1][n+1];
        String ans ="";
        for(int i=0;i<=m;i++){
            dp[i][0]="";
        }

        for(int j=0;j<=n;j++){
            dp[0][j]="";
        }

        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(str1.charAt(i-1)==str2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+str1.charAt(i-1);

                }else{
                    dp[i][j]="";
                }
                String tempString = dp[i][j];
                ans = ans.length()>tempString.length()?ans:tempString;
            }
        }

        
        return ans.length()>0?ans:null;


    }

小贴士

1.这道题和前文最长公共子序列的代码基本一致，主要改变就是连续子串它不能断，所以不相等的时候直接置为空字符串。

"" 是一个合法的、实实在在、有效的 String 类实例对象，只是这个对象里没有任何字符（字符长度为 0），对象内容为空；

null 表示一个 String 类型的变量，没有指向任何内存地址，没有绑定任何 String 对象，不占用任何内存空间，内存中完全没有这个对象的痕迹，是【悬空状态】

动态规划-斐波那契数列

Mon, 19 Jan 2026 04:30:00 +0000

求解代码

public int Fibonacci(int n) {
        
        if(n==1||n==2){
            return 1;
        }

        return Fibonacci(n-1)+Fibonacci(n-2);

    }

二分法-寻找峰值

Sat, 10 Jan 2026 18:42:01 +0000

求解代码

因为本题假设nums[-1]=nums[n]=-∞，所以，只要数组中存在一个元素比相邻的元素大，那么沿着它就一定可以找到一个峰值。

使用二分查找，比较mid和mid+1位置的值，如果mid位置的值更大，则左侧存在峰值；

如果mid+1位置的值更大，则右侧存在峰值。

public int findPeakElement (int[] nums) {
        int left = 0;
		int right = nums.length;

		while(left<right){
			int mid = left+((right-left)>>1);
			if(nums[mid]>nums[mid+1]){
				right=mid;
			}else{
				left=mid+1;
			}
		}
		return left;
    }

注意⚠️：

这里说明一下为什么无序数组也能使用二分查找，主要是这道题通过比较nums[mid]和nums[mid+1]，可以确定峰值的位置区间，这满足二分的核心条件，所以无序也能用二分。

编辑距离-手撕

Sat, 27 Dec 2025 21:13:21 +0000

求解代码

这道题面试遇到过，是一道比较经典的动态规划题。

先求出word1和word2的长度，然后把初始条件和状态转移方程写出来，基本上这题就完成了。

初始条件：

当j为0时，执行删除操作；

当i为0时，执行插入操作。

public int minDistance(String word1,String word2){
		int m = word1.length();
		int n = word2.length();

		int[][] dp = new int[m+1][n+1];

		for(int i=0;i<=m;i++){
			dp[i][0]=i;
		}
		for(int j=0;j<=n;j++){
			dp[0][j]=j;
		}

		for(int i=1;i<=m;i++){
			for(int j=1;j<=n;j++){
				if(word1.charAt(i-1)==word2.charAt(j-1)){
					dp[i][j]=dp[i-1][j-1];
				}else{
					dp[i][j]=Math.min(Math.min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1])+1;
				}
			}
		}
		return dp[m][n];
	}

含重复元素的子集生成

Wed, 12 Nov 2025 22:28:35 +0000

求解思路

当数组中存在重复元素时,暴力枚举会产生大量重复子集。这里把"是否选择某个元素"的问题,转化为"选择该元素几个"的问题,自然避免了重复。

代码实现详解

public static List<List<Integer>> subsetsWithDup(int[] nums) {
    List<List<Integer>> ans = new ArrayList<>();
    Arrays.sort(nums);  // 排序让相同元素聚在一起
    f(nums, 0, new int[nums.length], 0, ans);
    return ans;
}

public static void f(int[] nums, int i, int[] path, int size, List<List<Integer>> ans) {
    if (i == nums.length) {
        // 到达边界,收集当前路径
        ArrayList<Integer> cur = new ArrayList<>();
        for (int j = 0; j < size; j++) {
            cur.add(path[j]);
        }
        ans.add(cur);
    } else {
        // 找到下一组不同元素的起始位置
        int j = i + 1;
        while (j < nums.length && nums[i] == nums[j]) {
            j++;
        }
        
        // 决策1: 当前这组数,一个都不要
        f(nums, j, path, size, ans);
        
        // 决策2: 当前这组数,要1个、2个、3个...
        for (; i < j; i++) {
            path[size++] = nums[i];
            f(nums, j, path, size, ans);
        }
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~