牛客网左程云老师的算法视频个人总结

第一节课

第一题：题意与leetcode354的问题相同

算法原型 最长递增子序列问题

/*
 * 题意：求出给定序列的最长递增子序列的长度，给定序列不是有序的，子序列不是子数组，元素在原数组中不必是连续的
 *
 */
/*
 * solutions1: 时间复杂度O(n^2),空间复杂度O(n)
 * 新建一个辅助数组h,h[i]表示以nums[i]结尾的最长递增子序列的长度
 * h[i]值的确定，需要nums[i]与nums[j](0<=j<i)做比较，h[i] = h[j] + 1 (when nums[j] < nums[i]),找出这些值中的最大值即最终的nums[i]
 * 如果nums[i]最小的话，则h[i] = 1;
 * 因为h[i]值的确定需要nums[i]进行最多i-1次比较，所以时间复杂度为O(n^2)
 */
/*
 * solution2:  时间复杂度O(n*log(n)),空间复杂度O(n)
 * 新建一个辅助数组h,h[i]表示遍历到当前nums[j]位置时长度为i+1的递增子序列的最小末尾
 * h填入值的部分称作有效区，还未填入值的部分称作无效区
 * h[i]值的确定，h[0] = nums[0],在遍历nums 的同时，在h[i]中找到第一个大于等于nums[j]的数，并将其替换为为nums[j]，如果没找到则将h有效区后一个元素置为nums[j]
 * h[i]会一直保持有序状态，所以找第一个大于等于nums[j]的数可以用二分法,最后返回h有效区的长度即可
 * 由于在遍历的同时采用了时间复杂度为log(n)的二分查找，故时间复杂度为O(n*log(n))
 */
/*
 * 实现solution2
 */
public class LongestSubSequence {
    public int getLonggestLen(int[] nums) {
        int maxLen = 0;
        if (nums.length == 0)
            return maxLen;
        int[] h = new int[nums.length];
        h[0] = nums[0];
        maxLen = 1;
        for (int i = 1; i < nums.length; i++) {
            int pos = getPos(h, 0, maxLen - 1,nums[i]);
            if (pos == -1) {
                h[maxLen++] = nums[i];
            } else
                h[pos] = nums[i];
        }
        return maxLen;
    }
    public int getPos(int[] h, int left, int right, int num) {
        if (left <= right) {
            int mid = left + (right - left) / 2;
            if (h[mid] >= num) {
                int pos = getPos(h, left, mid - 1, num);
                if (pos == -1)
                    return mid;
                return pos;
            } else {
                return getPos(h, mid + 1, right, num);
            }
        }
        return -1;
    }
    public static void main(String[] args){
        LongestSubSequence l = new LongestSubSequence();
        int[]  nums = {1,3,6,7,9,4,10,5,6};
        l.getLonggestLen(nums);
    }
}

回归到本题的解法

import java.util.Arrays;
import java.util.Comparator;
/*
 * 题意：CackingCodingInterview上的叠罗汉问题，leetcode上的沙皇问题
 *         将最长递增子序列扩展到了二维
 */
/*
 * solutions : 时间复杂度O(n+n*log(n)+n*log(n)) 也就是n*log(n)
 * 目标是将二维数组抽象成一维数组，再利用解最长递增子序列的解法来解决这个问题
 * 首先我们需要将二维数组排序，排序策略是先按照array[i][0]排序，在array[i][0]相同的情况下，按照array[i][1]倒序排序
 * 为了排序我们可将array抽象成一个类A，二元组的两个元素分别是这个类A的两个成员变量
 * 将array转化为A的数组，给A自实现一个排序函数（按照上面的排序策略）
 * 接下来就转化为了最长递增子序列问题，将类A数组的h成员变量看作之前的一维数组就好了
 */
public class Leetcode354 {
    public int maxEnvelopes(int[][] envelopes) {
        if (envelopes.length < 2)
            return envelopes.length;
        A[] a = new A[envelopes.length];
        for (int i = 0; i < envelopes.length; i++) {
            a[i] = new A(envelopes[i][0],envelopes[i][1]);
        }
        Arrays.sort(a,new Comparator<A>(){
            @Override
            public int compare(A a, A b) {
                if (a.w > b.w) {
                    return 1;
                } else if (a.w < b.w) {
                    return -1;
                } else {
                    if (b.h > a.h) {
                        return 1;
                    } else if (b.h < a.h) {
                        return -1;
                    } else
                        return 0;
                }
            }
        });
        int maxLen = 0;
        int[] h = new int[envelopes.length];
        h[0] = a[0].h;
        for (int i = 1; i < envelopes.length; i++) {
            int pos = getPos(h, 0, maxLen - 1,a[i].h);
            if (pos == -1) {
                h[maxLen++] = a[i].h;
            } else
                h[pos] = a[i].h;
        }
        return maxLen;
    }
    public int getPos(int[] h, int left, int right, int num) {
        if (left <= right) {
            int mid = left + (right - left) / 2;
            if (h[mid] >= num) {
                int pos = getPos(h, left, mid - 1, num);
                if (pos == -1)
                    return mid;
                return pos;
            } else {
                return getPos(h, mid + 1, right, num);
            }
        }
        return -1;
    }
    public static void main(String[] args){
        Leetcode354 l = new Leetcode354();
        int [][] envelopes = {{5,1},{6,4},{6,7},{2,3}};
        l.maxEnvelopes(envelopes);
    }

}
class A {
    int w = 0;
    int h = 0;
    public A(int w, int h) {
        this.w = w;
        this.h = h;
    }
}