java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

解题思路：时间复杂度O($n^2\ast n$),空间复杂度O(n)

1. 90题的衍生题，此题需要处理的条件更多
2. 首先保证序列至少2个元素
3. 在原序列的基础上，找到升序排列的子集
4. 剩余操作和90题一样
5. 示例放在了代码注释里面。

🏆LeetCode90. 子集 IIhttps://blog.csdn.net/grd_java/article/details/136670669

代码

class Solution {
    int[] nums;
    int len;
    List<List<Integer>> ans = new ArrayList<List<Integer>>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        this.nums = nums;this.len = nums.length;
        List<Integer> records = new ArrayList<>();
        backTracking(records,0,Integer.MIN_VALUE);
        return ans;
    }

    /**
     * 回溯算法
     * @param records 保存当前序列
     * @param start 起始位置
     * @param last 当前序列上一个插入的元素
     * 4    6       7       7
     *
     * 选   6>4选    7>6选   7 = 7选    得到序列[4,6,7,7]
     *                      试图不选这个7，发现前面也有一个7，则跳过
     *              试图不选这个7，发现前面是6，和当前不一样，所以不会重复
     * 选   选       不选     7>6 选     得到序列[4,6,7]
     *                      试图不选这个7，发现前面是6，不一样，可以不选这个值
     * 选   选       不选     不选       得到序列[4,6]
     *     试图不选这个6，前面4，不一样，可以不选
     * 选   不选      7>4选   7==7选     得到序列[4,7,7]
     *                      试图不选7，前面是7，相同，则跳过
     *              试图不选这个7，前面4，不同，可不选
     * 选   不选      不选    7>4选       得到序列[4,7]
     *                      试图不选这个7，前面4，不一样，可以不选
     * 选   不选      不选    不选        得到序列[4],但是只有一个元素，构不成升序序列，淘汰掉
     * 试图不选，前面没有值，可以不选
     * 不选  选       7>6选   7=7选      得到序列[6,7,7]
     * 不选  选       不选     选         得到序列[6,7]
     * 不选  选       不选     不选        得到[6],淘汰
     * 不选  不选      选      选         得到[7,7]
     * 不选  不选      选      不可以不选   跳过
     * 不选  不选      不选     选         得到[7] 淘汰
     * 不选  不选      不选     不选       得到[] 淘汰
     *
     * 最终得到答案[[4,6,7,7],[4,6,7],[4,6],[4,7,7],[4,7],[6,7,7],[6,7],[7,7]]
     */
    public void backTracking(List<Integer> records,int start,int last){
        if(start == len){
            if (records.size()>=2) ans.add(new ArrayList<>(records));//低于两个元素的序列，无法组成升序序列
        }else{
            int num = nums[start];
            if(num >= last){//如果>=上个元素，才能选择，构成升序序列
                records.add(num);
                backTracking(records,start+1,num);
                records.remove(records.size()-1);
            }
            //如果当前元素和上个元素一样，则不可以枚举不选当前元素的情况
            if(num != last) backTracking(records,start+1,last);
        }
    }
}