最长递增子序列

最长递增子序列#

题目：给定数组 arr，返回 arr 的最长递增子序列。

举例：arr=[2,1,5,3,6,4,8,9,7]，返回的最长递增子序列为[1,3,4,8,9]。

方法一：动态规划#

这题递归可不好搞吧，时间复杂度貌似为o(n^3)。

我们用动态规划，leetcode仅仅让求最长递归子序列的长度，那么dp数组的dp[i]就是以arr[i]为结尾的最长递归子序列长度。（为啥dp[i] 的意义不是以arr[i]为开头的最长长度呢？因为我们连dp[0]都没法初始化，所以不行）

dp[0] 很简单我们就知道是1

dp[1] 为如果arr[1] > arr[0] 则dp[1] = dp[0] + 1

dp[2] 如果arr[2] > arr[0] ,我们还不能着急赋值，如果arr[2] 也大于 arr[1] ，那么我们应该选择dp[0] 和 dp[1] 中最大的一个：dp[2] = Math.max(dp[0], dp[1]) + 1

dp[3] 在arr[3] > arr[i] (0<= i < 3) 的情况下，找到dp[i] 中最大的，加到dp[3]

代码：

    /**
     * 根据arr，获得dp数组，dp数组意义为以第i个元素结尾的最长递增子序列
     * @param arr
     * @return
     */
    public int[] getdp1(int[] arr) {
        int[] dp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (arr[j] < arr[i]) {
                    dp[i] = Math.max(dp[j] + 1, dp[i]);
                }
            }
        }
        return dp;
    }

得到dp数组后，我们就可以还原最长递增子序列了

在dp数组中找到最大值len，这个最大值就是最长递增子序列的长度。

这个最大值在dp数组中的索引值index，然后最长递增子序列的最后一个元素就是arr[index]

然后我们开始找最长递增子序列的倒数第二个元素，它满足：倒数第二个元素肯定比最后一个元素值小，而且倒数第二个元素的dp[i] 正好等于倒数第一元素的dp[i] - 1

然后就是倒数第三个元素和倒数第二个元素比较。。。。。。

代码：

    /**
     * 根据dp数组的信息：结尾的索引，最长递增子序列的长度。从而求出最长递增子序列
     * @param arr
     * @param dp
     * @return
     */
    public int[] generateLIS(int[] arr, int[] dp) {
        int len = 0;
        int index = 0;
        // 找出dp数组的最大值，和最大值的index
        for (int i = 0; i < arr.length; i++) {
            if (len < dp[i]) {
                len = dp[i];
                index = i;
            }
        }
        int[] res = new int[len];
        res[--len] = arr[index];
        for (int i = index - 1; i >= 0; i--) {
            if (arr[i] < arr[index] && dp[i] == dp[index] - 1) {
                res[--len] = arr[i];
                index = i;
            }
        }
        return res;
    }

主方法：

    // 主方法
    public int[] lengthOfLIS(int[] arr) {
        if (arr.length == 0 || arr == null) {
            return null;
        }
        int[] dp = getdp1(arr);
        return generateLIS(arr, dp);
    }

方法二：动态规划 + 二分#

我感觉左神和leetcode上的题解思路都是一致的，只不过左神用ends，leetcode上用tail，不过leetcode上给了更详细的思考过程。

添加了ends，right。ends数组的意义：ends[0] = 2，目前为止长度为1的递增子序列中的结尾值最小为2

ends[0..1]=[1,5]表示目前为止，长度为1的递增子序列中的结尾值最小为1，长度为2的递增子序列中的结尾值最小为5

ends[0..2]=[1,3,6]表示目前为止，长度为1的递增子序列中的结尾值最小为1，长度为2的递增子序列中的结尾值最小为3,长度为3的递增子序列中的结尾值最小为6

代码：

    /**
     * 在查找ends数组中使用二分法，因此降低了时间复杂度
     * @param arr
     * @return
     */
    public int[] getdp2(int[] arr) {
        int[] dp = new int[arr.length];
        int[] ends = new int[arr.length];
        ends[0] = arr[0];
        dp[0] = 1;
        int right = 0;
        int l = 0;
        int r = 0;
        int m = 0;
        for (int i = 1; i < arr.length; i++) {
            l = 0;
            r = right;
            // 二分法
            while (l <= r) {
                m = (l + r) / 2;
                if (arr[i] > ends[m]) {
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            right = Math.max(right, l);
            ends[l] = arr[i];
            dp[i] = l + 1;
        }
        return dp;
    }

信封嵌套#

给定一个 N 行 2 列的二维数组，每一个小数组的两个值分别代表一个信封的长和宽。如果信封 A 的长和宽都小于信封 B，那么信封 A 可以放在信封 B 里，请返回信封最多嵌套多少层。

matrix = {{3,4},
{2,3},
{4,5},
{1,3},
{2,2},
{3,6},
{1,2},
{3,2},
{2,4}
}

信封最多可以套 4 层，从里到外分别是{1,2},{2,3},{3,4},{4,5}，所以返回 4。

这题，既需要长度递增，也需要宽度递增。

先对长度递增排序，对于长度相等的对其宽度递减排序。

按此规律对信封排序，排序后的信封宽度从左到右为{3,2,4,3,2,6,4,2,5}

在这个数组中找到最长递增子序列的长度，就是所求。

    public class Envelope{
        private int len;
        private int wid;

        public Envelope(int len, int wid) {
            this.len = len;
            this.wid = wid;
        }
    }
   
    public class EnvelopeComparator implements Comparator<Envelope> {
        @Override
        public int compare(Envelope o1, Envelope o2) {
            return o1.len != o2.len ? o1.len - o2.len : o2.wid - o1.wid;
        }
    }
    public Envelope[] getSortedEnvelopes(int[][] matrix) {
        Envelope[] res = new Envelope[matrix.length];
        for (int i = 0; i < matrix.length; i++) {
            res[i] = new Envelope(matrix[i][0], matrix[i][1]);
        }
        Arrays.sort(res, new EnvelopeComparator());
        return res;
    }
    
    public int maxEnvelopes(int[][] matrix) {
        Envelope[] envelopes = getSortedEnvelopes(matrix);
        int[] ends = new int[matrix.length];
        ends[0] = envelopes[0].wid;
        int right = 0;
        int l = 0;
        int r = 0;
        int m = 0;
        for (int i = 1; i < envelopes.length; i++) {
            l = 0;
            r = right;
            while (l <= r) {
                m = (l + r) / 2;
                if (envelopes[i].wid > ends[m]) {
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            right = Math.max(right, l);
            ends[l] = envelopes[i].wid;
        }
        return right + 1;
    }