leetcode动态规划笔记三---单序列型

单序列型DP

相比一维DP，这种类型状态转移与过去每个阶段的状态都有关。

• Longest Increasing Subsequence : 求最大最小值
• Perfect Squares : 求某个规模值
• Increasing Triplet Subsequence : 求是否存在
• Coin Change : 求最大最小值
• Integer Break : 求最大最小值
• Largest Divisible Subset : 求最大最小值
• Combination Sum IV : 求方法总数
• 646. Maximum Length of Pair Chain : 求最长
• 650. 2 Keys Keyboard : 求最短
• 376. Wiggle Subsequence : 求最值

Perfect Squares :

方法一 ： 自底向上 递推 + memo

f(n) = min{f(i) + f(n-i), i = 1...n-1}

class Solution {
    public int numSquares(int n) {
        int[] memo = new int[n];

        for(int i = 1; i <= n; i++){
            if(i * i <= n){
                memo[i*i - 1] = 1;
            }
        }

        if(memo[n-1] == 1) return 1;

        memo[1] = 2;
        for(int i = 3; i <= n; i++){
            if(memo[i-1] == 1) continue;

            int left = 1;
            int right = i - 1;

            int mini = Integer.MAX_VALUE;
            while(left <=  right){
                if(left + right == i){
                    mini = Math.min(mini, memo[left - 1] + memo[right - 1]);
                }
                left ++; right--;
            }
            memo[i-1] = mini;
        }

        return memo[n - 1];
    }
}

方法二： 递推 + memo

另外，本题有个四平方数之和定理，具体参考

class Solution {
    public int numSquares(int n) {
        int[] memo = new int[n + 1];
        memo[0] = 0;

        for(int i = 1; i <= n; i++){
            int mini = Integer.MAX_VALUE;

            for(int j = 1; j <= i; j ++){
                int t = j*j;

                if(t > i) break;
                if(t == i) mini = 1;
                else mini = Math.min(mini, memo[t] + memo[i-t]);
            }

            memo[i] = mini;
        }
        return memo[n];
    }
}

Longest Increasing Subsequence

方法一 ： 自底向上，递推 + memo

这道题的状态转移想了比较久，没有想出来，给出grandyang的参考.

参考中，还介绍了nlog(n)的解法，用了二搜法。

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length == 0) return 0;

        int[] memo = new int[nums.length];
        memo[0] = 1;

        int maxi = 1;
        for(int i = 1; i < nums.length; i++){

            memo[i] = 1;

            for(int j = i - 1; j >= 0; j--){
                if(nums[i] > nums[j])
                memo[i] = Math.max(memo[i], memo[j] + 1);
            }
            maxi = Math.max(memo[i], maxi);
        }

        return maxi;
    }
}

Increasing Triplet Subsequence : 求是否存在

方法一 ： 自底向上 递推 + memo

class Solution {
    public boolean increasingTriplet(int[] nums) {
        if(nums.length == 0) return false;

        int[] memo = new int[nums.length];
        memo[0] = 1;

        boolean exist = false;
        for(int i = 1; i < nums.length; i ++){
            memo[i] = 1;
            for(int j = 0; j < i; j ++){
                if(nums[i] > nums[j]){
                    memo[i] = Math.max(memo[j] + 1, memo[i]);
                }
            }

            if(memo[i] == 3){
                exist = true;break;
            }
        }

        return exist;
    }
}

Coin Change

方法一: 自底向上

递推 + memo

如果直接用用模除，将得到错误结果

dp方法没有可优化了，用 递归 + 减枝还可以优化，参考

减枝是一种优化方法，一般用于dfs/bfs中，通过条件过滤掉对搜索空间树的搜索，参考

class Solution {
    public int coinChange(int[] coins, int amount) {

        Arrays.sort(coins);
        int[] memo = new int[amount + 1];

        for(int i = 1; i <= amount; i++){

            memo[i] = Integer.MAX_VALUE;

            for(int j = coins.length - 1; j >= 0; j--){
                if(i < coins[j]) continue;

                if(i == coins[j]){
                    memo[i] = 1;
                    continue;
                }

                int m = i - coins[j];//此处若修改为 m = i % coins[j]会出错
                if(memo[m] != -1){
                    memo[i] = Math.min(memo[i], 1 + memo[m]);
                }
            }

            memo[i] = (memo[i] == Integer.MAX_VALUE) ? -1 : memo[i];
        }

        return memo[amount];
    }
}

Integer Break

方法一 ： 自底向上， 递推 + memo

与coin change很像

class Solution {
    public int integerBreak(int n) {
        int[] memo = new int[n + 1];
        memo[0] = 1;
        memo[1] = 1;
        memo[2] = 1;

        for(int i = 3; i <= n; i++){
            int a = i / 2 + 1;
            for(int j = 1; j < a; j++){
                int x = Math.max(j, memo[j]);
                int y = Math.max(i - j, memo[i - j]);
                memo[i] = Math.max(memo[i], x * y);
            }
        }

        return memo[n];
    }
}

Largest Divisible Subset

方法一 ： 自底向上， 递推 + memo

class Solution {
    public List<Integer> largestDivisibleSubset(int[] nums) {
        if(nums.length < 1) return new ArrayList<>();

        List<List<Integer>> memo = new ArrayList<List<Integer>>();
        Arrays.sort(nums);

        int gIdx = 0;
        int gLen = 0;

        List<Integer> li = new ArrayList<>();
        li.add(nums[0]);
        memo.add(li); // 1

        for(int i = 1; i < nums.length; i ++){
            int longIdx = i;
            int longLen = 0;

            for(int j = 0; j < i; j++){
                int tlen = memo.get(j).size();
                if(nums[i] % memo.get(j).get(tlen - 1) == 0){
                    if(longLen < tlen){
                        longLen = tlen; longIdx = j;
                    }
                }
            }

            if(longIdx == i){
                List<Integer> li2 = new ArrayList<>();
                li2.add(nums[i]);
                memo.add(li2);
            }
            else{
                List<Integer> li3 = new ArrayList<>(memo.get(longIdx));
                li3.add(nums[i]);
                memo.add(li3);
                if(memo.get(i).size() > gLen){
                    gIdx = i; gLen = memo.get(i).size();
                }
            }
        }

        if(gLen == 0) return memo.get(0);
        return memo.get(gIdx);
    }
}

Combination Sum IV

方法一： 自顶向下 回溯法 TimeLimitExceed, 11 / 17

class Solution {
    public int combinationSum4(int[] nums, int target) {
        Arrays.sort(nums);
        return dfs(nums, target);
    }

    int dfs(int[] nums, int tgt){

        if(tgt == 0){
            return 1;
        }
        else if(tgt < 0){
            return 0;
        }

        int sumC = 0;
        for(int i = 0; i < nums.length; i ++){
            int newTgt = tgt - nums[i];
            if(newTgt >= 0){
                sumC += dfs(nums, newTgt);
            }
            else{
                break;
            }
        }

        return sumC;
    }
}

方法二：自底向上 递推 + memo

class Solution {
    public int combinationSum4(int[] nums, int target) {
        Arrays.sort(nums);

        int[] memo = new int[target + 1];
        memo[0] = 0;

        for(int i = 1; i <= target; i++){

            for(int j = 0; j < nums.length; j++){
                if(i < nums[j]){
                    continue;
                }

                if(i == nums[j]){
                    memo[i] += 1;
                }
                else{
                    int t = i - nums[j];
                    if(memo[t] != 0){
                        memo[i] += memo[t];
                    }
                }
            }

        }

        return memo[target];
    }
}

646. Maximum Length of Pair Chain

方法一 ： 耗时47ms

这是一道变型的Longest Increase Subsequence；注意，这里有二维数组的排序方法

class Solution {
    public int findLongestChain(int[][] pairs) {
        int len = pairs.length;
        if(len < 2) return len;
        Integer[][] p = new Integer[len][2];
        for(int i = 0; i < len; i ++){
            p[i][0] = pairs[i][0];
            p[i][1] = pairs[i][1];
        }

        Arrays.sort(p, new Comparator<Integer[]>(){
            public int compare(Integer[] o1, Integer[] o2){
                return o1[0] - o2[0];
            }
        });

        int[] dp = new int[len];
        dp[0] = 1;

        for(int i = 1; i < len; i ++){

            int maxi = 1;
            for(int j = 0; j < i; j ++){
                if(p[j][1] < p[i][0]){
                    maxi = dp[j] + 1;
                }
            }

            dp[i] = maxi;
        }

        return dp[len - 1];
    }
}

方法二 ： 使用自己的快排，耗时3ms

class Solution {
    public int findLongestChain(int[][] pairs) {
        if (pairs == null)
            return 0;
        int len = pairs.length;
        if (len < 2)
            return len;
        qsort(pairs, 0, len - 1);
        int sum = 1;
        int end = pairs[0][1];
        for (int i = 1; i < len; ++i) {
            if (pairs[i][0] > end) {
                ++sum;
                end = pairs[i][1];
            }
        }
        return sum;
    }

    private void qsort(int[][] pairs, int begin, int end) {
        if (begin >= end)
            return;
        int key = pairs[begin][1];
        int[] keyPair = pairs[begin];
        int i = begin, j = end;
        while(i < j) {
            while(i < j && key <= pairs[j][1])
                --j;
            pairs[i] = pairs[j];
            while(i < j && key >= pairs[i][1])
                ++i;
            pairs[j] = pairs[i];
        }
        pairs[i] = keyPair;
        qsort(pairs, begin, i - 1);
        qsort(pairs, i + 1, end);
    }
}

650. 2 Keys Keyboard

方法一：递推 + memo

还有递推方法，参考

class Solution {
    public int minSteps(int n) {
        int[] dp = new int[n];
        dp[0] = 0;

        for(int i = 2; i <= n; i++){

            int halfi = i >> 1;
            int mini = i;
            for(int j = 2; j <= halfi; j++){
                if(i % j == 0){
                    mini = Math.min(mini, dp[j-1] + 1 + i / j - 1);
                }
            }
            dp[i-1] = mini;
        }

        return dp[n-1];
    }
}

376. Wiggle Subsequence :

方法一： 递推 + memo

这道题是LIS的变形，原理都一样

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length == 0) return nums.length;

        int[][] dp = new int[nums.length][2];

        dp[0][0] = dp[0][1] = 1;

        for(int i = 1; i < nums.length; i ++){

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

        return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
    }
}