动态规划 - Dp - 最长上升子序列

 

LeetCode - 面试题 17.08. 马戏团人塔

                     

攻克该题需要一个先验知识， 需要了解  最长上升子序列 这个题目的dp暴力解法， 以及贪心思路。 本题就是他从一维拓扑为二维的一个题。 

如果有了以上知识的了解， 下面代码粗略了解下思路即可。

 

dp暴力做法 - 超时 O (N ^ 2)

class Solution {
    public int bestSeqAtIndex(int[] height, int[] weight) {
        int n = height.length;
        if(n == 0)  return 0;
        int[] dp = new int[n + 1];
        int[][] a = new int[n + 1][2];
        for(int i = 1; i <= n; i++){
            a[i][0] = height[i - 1];
            a[i][1] = weight[i - 1];
        }
        Arrays.sort(a, (o1, o2) -> {
            if(o1[0] == o2[0])  return o2[1] - o1[1];
            return o1[0] - o2[0];
        });
        Arrays.fill(dp, 1);
        int max = 1;
        for(int i = 2; i <= n; i++){
            for(int k = 1; k < i; k++){
                if(a[i][1] > a[k][1] && a[i][0] > a[k][0]){
                    dp[i] = Math.max(dp[i], dp[k] + 1);
                }
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }
}

贪心 -  O(N * size)   157 ms, 在所有 Java 提交中击败了5.16%的用户

注意一个坑， 当按照身高升序排序后， 体重需要降序排序， 这样才能排除掉身高一样， 体重上升的情况。

class Solution {
    public int bestSeqAtIndex(int[] height, int[] weight) {
        int n = height.length;
        if(n == 0)  return 0;
        int[][] a = new int[n + 1][2];
        for(int i = 1; i <= n; i++){
            a[i][0] = height[i - 1];
            a[i][1] = weight[i - 1];
        }
        //排序后， 高度严格单调递增， 求体重的最长上升子序列
        Arrays.sort(a, (o1, o2) -> {
            if(o1[0] == o2[0])  return o2[1] - o1[1];
            return o1[0] - o2[0];
        });
        //使用贪心思想， 每一个体重都是接在比他小的数之后， 形成一个单调递增的数组
        List<Integer> list = new ArrayList();
        for(int i = 1; i <= n; i++){
            int size = list.size();
            if(size == 0 || list.get(size - 1) < a[i][1]) list.add(a[i][1]);
            else {
                for(int j = 0; j < size; j++){
                    if(list.get(j) >= a[i][1]) { //注意， 这里是大于等于
                        list.set(j, a[i][1]);
                        break;
                    }
                }
            }
        }
        return list.size();
    }
}

贪心 + 二分  O(N * log(Size) ）  执行用时：84 ms, 在所有 Java 提交中击败了25.40%的用户

class Solution {
    public int bestSeqAtIndex(int[] height, int[] weight) {
        int n = height.length;
        if(n == 0)  return 0;
        int[][] a = new int[n + 1][2];
        for(int i = 1; i <= n; i++){
            a[i][0] = height[i - 1];
            a[i][1] = weight[i - 1];
        }
        //排序后， 高度严格单调递增， 求体重的最长上升子序列
        Arrays.sort(a, (o1, o2) -> {
            if(o1[0] == o2[0])  return o2[1] - o1[1];
            return o1[0] - o2[0];
        });
        //使用贪心思想， 每一个体重都是接在比他小的数之后， 形成一个单调递增的数组
        List<Integer> list = new ArrayList();
        for(int i = 1; i <= n; i++){
            int size = list.size();
            if(size == 0 || list.get(size - 1) < a[i][1]) list.add(a[i][1]);
            else {
                int l = 0, r = size - 1;
                while(l < r){
                    int mid = l + r >> 1;
                    if(list.get(mid) >= a[i][1]) r = mid;
                    else l = mid + 1;
                }
                list.set(l, a[i][1]);
            }
        }
        return list.size();
    }
}

最后优化 - 把List 改成int[]   执行用时：66 ms, 在所有 Java 提交中击败了93.65%的用户

class Solution {
    public int bestSeqAtIndex(int[] height, int[] weight) {
        int n = height.length;
        if(n == 0)  return 0;
        int[][] a = new int[n + 1][2];
        for(int i = 1; i <= n; i++){
            a[i][0] = height[i - 1];
            a[i][1] = weight[i - 1];
        }
        //排序后， 高度严格单调递增， 求体重的最长上升子序列
        Arrays.sort(a, (o1, o2) -> {
            if(o1[0] == o2[0])  return o2[1] - o1[1];
            return o1[0] - o2[0];
        });
        //使用贪心思想， 每一个体重都是接在比他小的数之后， 形成一个单调递增的数组
        int[] list = new int[n];
        int size = 0;
        for(int i = 1; i <= n; i++){
            if(size == 0 || list[size - 1] < a[i][1]) {
                list[size++] = a[i][1];
            }else {
                int l = 0, r = size - 1;
                while(l < r){
                    int mid = l + r >> 1;
                    if(list[mid] >= a[i][1]) r = mid;
                    else l = mid + 1;
                }
                list[l] = a[i][1];
            }
        }
        return size;
    }
}

 

 

LeetCode 面试题 08.13. 堆箱子

堆箱子。给你一堆n个箱子，箱子宽 wi、深 di、高 hi。箱子不能翻转，将箱子堆起来时，下面箱子的宽度、高度和深度必须大于上面的箱子。实现一种方法，搭出最高的一堆箱子。箱堆的高度为每个箱子高度的总和。

输入使用数组[wi, di, hi]表示每个箱子。

示例1:

 输入：box = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
 输出：6
示例2:

 输入：box = [[1, 1, 1], [2, 3, 4], [2, 6, 7], [3, 4, 5]]
 输出：10
提示:

箱子的数目不大于3000个。

 

class Solution {
    //求最大下降子序列和
    public int pileBox(int[][] box) {
        //以宽降序， 深升序， 避免宽相同时， 放入不同的深度
        Arrays.sort(box, (o1, o2) -> {
            if (o1[0] == o2[0] && o1[1] == o2[1])  return o1[2] - o2[2];
            if (o1[0] == o2[0]) return o1[1] - o2[1];
            return o2[0] - o1[0];
        });

        int n = box.length;

        int[] dp = new int[n];
        int max = 0;
        for (int i = n - 1; i >= 0; i--) {
            dp[i] = box[i][2];
            for (int k = n - 1; k > i; k--) {
                if (box[i][1] > box[k][1] && box[i][2] > box[k][2]) {
                    dp[i] = Math.max(dp[i], dp[k] + box[i][2]);
                }
            }
            if(max < dp[i]) max = dp[i];
        }

        return max;
    }
}