2021-01-18

子序列问题

常见的子序列分为以下：

• 递增子序列
• 最长连续递增子序列
• 求所有的递增子序列
• 信封嵌套

递增子序列

题目参见leetcode300

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

public int lengthOfLIS(int[] nums) {
        // dp的含义是以nums[i]结尾的最长递增子序列的长度
        int[] dp = new int[nums.length];
        int max = 1;
        for (int i = 0; i < nums.length; i++) {
            // 至少是自己
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }

最长递增子序列

题目参见leetcode674

public int findLengthOfLCIS(int[] nums) {
        if (nums.length == 0) return 0;
        int max = 0;
        int prev = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i - 1] >= nums[i]) prev = i;
            max = Math.max(max, i - prev + 1);
        }
        return max;
    }

求所有的递增子序列

题目参见leetcode 491

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
示例:
输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

思路：回溯

public Set<List<Integer>> res;

    public List<List<Integer>> findSubsequences(int[] nums) {
        res = new HashSet<>();
        dfs(new ArrayList(), nums, 0);
        return new ArrayList(res);
    }

    public void dfs(List<Integer> currList, int[] nums, int start) {
        if (currList.size() >= 2) {
            // 因为下面会remove 这里需要每次new一个list
            res.add(new ArrayList(currList));
        }
        for (int i = start; i < nums.length; i++) {
            if (currList.size() == 0 || currList.get(currList.size() - 1) <= nums[i]) {
                currList.add(nums[i]);
                dfs(currList, nums, i + 1);
                currList.remove(currList.size() - 1);
            }
        }

    }

信封嵌套

题目参见leetcode354

思路：这道题的关键是先对宽度升序，再对高度降序（降序的目的是保证同一宽度下只取一个进行嵌套）

public int maxEnvelopes(int[][] envelopes) {
        if(envelopes.length==0) return 0;
        // 先按照宽升序，再按照高降序
        Arrays.sort(envelopes,new Comparator<int[]>(){
            @Override
            public int compare(int[] o1,int[] o2){
                return o1[0]==o2[0]?o2[1]-o1[1]:o1[0]-o2[0];
            }
        });
        int[] arr=new int[envelopes.length];
        for(int i=0;i<envelopes.length;i++){
            arr[i]=envelopes[i][1];
        }
        // 转为求最长递增子序列问题
        return getMaxLength(arr);
    }

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