算法题解之动态规划

Arithmetic Slices

算术片的个数

思路（最优解）：序列型dp。每次记录一下以当前数为末尾的算术片的最大长度以及数的等差值。下一次就能求出算术片增加的个数。使用滚动指针来优化。时间复杂度O(n)，空间复杂度O(1)。

public class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        if (A.length < 3) {
            return 0;
        }
        
       int prev_res = 0;
       int prev_length = 2;
       int prev_diff = A[1] - A[0];
       
       for (int i = 2; i < A.length; i++) {
           if (prev_diff == A[i] - A[i - 1]) {
               prev_res += prev_length - 1;
               prev_length++;
           } else {
               prev_length = 2;
               prev_diff = A[i] - A[i - 1];
           }
       }
       return prev_res;
    }
}

Climbing Stairs

爬楼梯

思路：滚动指针优化到O(1)空间。开一个大小为2的数组，用模2方式来求解。

public class Solution {
    public int climbStairs(int n) {
        if (n == 1) {
            return 1;
        }
        int[] dp = new int[2];
        dp[0] = 1;
        dp[1] = 2;
        
        for (int i = 2; i < n; i++) {
            dp[i % 2] = dp[(i - 1) % 2] + dp[(i - 2) % 2];
        }
        return dp[(n - 1) % 2];
    }
}

Drop Eggs II

扔鸡蛋II

思路：状态：设一种丢法在最坏情况下需要丢p次能确定结果，状态dp[i][j]表示i个鸡蛋和j层楼的所有丢法的最小p值。

　　　方程：对于i个蛋，j层楼，要确定它的所有丢法的最小p值。先假定第一次在第k层丢（1<=k<=j），如果蛋碎了，那么我们只需要用剩下的鸡蛋测试k层以下的楼层，所以问题简化为k-1层和i-1个鸡蛋,因此对应的次数是dp[i-1][k-1]+1；如果蛋不碎，那么我们只需要检查比k较高的楼层; 所以问题简化为 j-k 和i个鸡蛋，即dp[i][j-k]+1。最坏情况应该是两者的最大值。而所有k(1~j)对应的次数的最小值就是最小p值。

　　　初始化：对于一个蛋的问题，p值是楼层数j。即dp[1][j] = j.

　　　结果：dp[m][n]

public class Solution {
    /**
     * @param m the number of eggs
     * @param n the umber of floors
     * @return the number of drops in the worst case
     */
    public int dropEggs2(int m, int n) {
        // Write your code here
        int[][] dp = new int[m+1][n+1];
        
        for (int j = 1; j <= n; j++) {
            dp[1][j] = j;
        }
        
        for (int i = 2; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i][j] = Integer.MAX_VALUE; 
                for (int first = 1; first <= j; first++) {
                    dp[i][j] = Math.min(Math.max(dp[i-1][first - 1] + 1, dp[i][j - first] + 1),
                    dp[i][j]);
                }
            }
        }
        
        return dp[m][n];
    }
}

Is Subsequence

判断是否是子序列

思路1:典型的双序列动态规划。 状态dp[i][j]表示s的前i个字符是否是t的前j个字符的子序列。时间复杂度O(s*t),空间复杂度O(s*t)，使用滚动数组可以讲空间优化到O(t)。

public class Solution {
    public boolean isSubsequence(String s, String t) {
        boolean[][] dp = new boolean[s.length() + 1][t.length() + 1];
        
        for (int j = 0; j <= t.length(); j++) {
            dp[0][j] = true;
        }
        
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 1; j <= t.length(); j++) {
                if (dp[i][j - 1]) {
                    dp[i][j] = true;
                } else {
                    dp[i][j] = dp[i - 1][j - 1] && s.charAt(i - 1) == t.charAt(j - 1);
                }
            }
        }
        return dp[s.length()][t.length()];
    }
}

思路2:使用two pointers。时间复杂度O(t)，空间复杂度O(1)。

public class Solution {
    public boolean isSubsequence(String s, String t) {
        if (s.length() == 0) return true;
        int indexS = 0, indexT = 0;
        while (indexT < t.length()) {
            if (t.charAt(indexT) == s.charAt(indexS)) {
                indexS++;
                if (indexS == s.length()) return true;
            }
            indexT++;
        }
        return false;
    }
}

 

思路3（最优解）：改进的two pointers，使用indexOf函数，时间复杂度仍然是O(t)。但是思路2调用了t次charAt函数，而这个方法只调用了s次函数。虽然时间复杂度相同，但是实际运行起来更快。

public class Solution {
    public boolean isSubsequence(String s, String t) {
        if (s.length() == 0) return true;
        int pt = 0;
        for (int ps = 0; ps < s.length(); ps++) {
            char c = s.charAt(ps);
            pt = t.indexOf(c, pt);
            if (pt == -1) {
                return false;
            }
            pt++;
        }
        return true;
    }
}

k Sum

k数和

思路：一道三维动态规划，状态和方程都比较容易想，初始化要想一下。

public class Solution {
    /**
     * @param A: an integer array.
     * @param k: a positive integer (k <= length(A))
     * @param target: a integer
     * @return an integer
     */
    public int kSum(int A[], int k, int target) {
        // write your code here
        int[][][] dp = new int[A.length + 1][k + 1][target + 1];
        for (int i = 1; i < A.length; i++) {
            for (int m = 1; m < target; m++) {
                if (A[i - 1] == m) {
                    dp[i][1][m] = 1;
                } else {
                    dp[i][1][m] = dp[i - 1][1][m];
                }
            }
        }
        
        for (int i = 2; i <= A.length; i++) {
            for (int j = 2; j <= Math.min(i, k); j++) {
                for (int m = 1; m <= target; m++) {
                    if (A[i - 1] < m) {
                        dp[i][j][m] = dp[i - 1][j - 1][m - A[i - 1]];
                    }
                    dp[i][j][m] += dp[i - 1][j][m];
                }
            }
        }
        return dp[A.length][k][target];
    }
}

 

Longest Increasing Subsequence

最长递增子序列

思路1：LIS是一道经典的dp题。用O(n^2)来做是一道简单的序列型动态规划。

public class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int[] dp = new int[nums.length];
        dp[0] = 1;
        for (int i = 1; i < dp.length; i++) {
            dp[i] = 1;
            for (int j = 0; j <= i - 1; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], 1 + dp[j]);
                }
            }
        }
        int res = 0;
        for (int i = 0; i < dp.length; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

思路2（最优解）：这道题还存在O(nlgn)的解法。在思路1中，每次我们计算dp[i]的时候，都要往前面遍历找到一个nums[j]，使得nums[j] < nums[i]并且dp[j]值最大。在这个过程中其实有些数我们不用找。比如说长度为2的子序列有（3，5），（3，10），（2，4），那么我们只需要与4比较就可以，而不需要与5和10比较。因此我们定义一个数组B，其中B[i]表示长度为i的所有子序列中最小的末尾数。可以证明B是一个单调递增的数组。因此每次我们只需要使用二分查找找到小于nums[i]的最大值，返回它的长度i即可。

public class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int res = 0;
        int[] B = new int[nums.length + 1];
        for (int i = 0; i < B.length; i++) {
            B[i] = Integer.MAX_VALUE;
        }
        
        for (int i = 0; i < nums.length; i++) {
            int len = binarySearch(B, nums[i]) + 1;
            res = Math.max(res, len);
            B[len] = Math.min(B[len], nums[i]);
        }
        
        return res;
    }
    
    public int binarySearch(int[] B, int k) {
        int start = 0;
        int end = B.length - 1;
        while (start + 1 < end) {
            int mid = (start + end) / 2;
            if (B[mid] >= k) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (B[end] < k) {
            return end;
        }
        if (B[start] < k) {
            return start;
        }
        return 0;
    }
}

Minimum Adjustment Cost

最小调整代价

思路：状态：dp[i][j]表示对0～i的数做调整，最后一个数调整到数j的最小代价。

　　　方程：dp[i][j] = min(dp[i-1][m]) + cost(i,j)，即序列0~i-1做调整，最后一个数调整到m的代价的最小值，加上第i个数调整到j的代价。为保证满足条件，m的范围是（j - taget ~ j + target）。

　　　初始化：对于dp[0][j]，就是与j的差值。

　　   结果：dp矩阵最后一行的最小值。

public class Solution {
    /**
     * @param A: An integer array.
     * @param target: An integer.
     */
    public int MinAdjustmentCost(ArrayList<Integer> A, int target) {
        // write your code here
        
        int[][] dp = new int[A.size()][101];
        for (int j = 1; j < 101; j++) {
            dp[0][j] = Math.abs(j - A.get(0));
        }
        
        for (int i = 1; i < A.size(); i++) {
            for (int j = 1; j < 101; j++) {
                int cost = Math.abs(j - A.get(i));
                
                int min = Math.max(1, j - target);
                int max = Math.min(100, j + target);
                
                int pre_min_cost = Integer.MAX_VALUE;
                for (int m = min; m <= max; m++) {
                    pre_min_cost = Math.min(dp[i-1][m], pre_min_cost);
                }
                dp[i][j] = pre_min_cost + cost;
            }
        }
        
        int res = Integer.MAX_VALUE;
        for (int j = 1; j < 101; j++) {
            res = Math.min(dp[A.size() - 1][j], res);
        }
        return res;
    }
}

Partition Equal Subset Sum

和相同的二划分

思路1:每个划分的和应该是总和的一半，问题转化为01背包问题。状态dp[i][j]表示前j个数能否恰好装满容量为j的背包。

public class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 != 0) {
            return false;
        }
        
        ／／转化为01背包问题
        int capacity = sum / 2;
        boolean[][] dp = new boolean[capacity + 1][nums.length + 1];
        
        dp[0][0] = true;
        for (int i = 0; i <= capacity; i++) {
            for (int j = 1; j <= nums.length; j++) {
                if (nums[j - 1] <= i) {
                    dp[i][j] = dp[i - nums[j - 1]][j - 1] || dp[i][j - 1];
                } else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        
        return dp[capacity][nums.length];
        
    }
}    

思路2(最优解):将思路1用滚动数组优化，这里在循环时要将背包容量i改为从大到小循环（见01背包问题的空间优化）。

public class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 != 0) {
            return false;
        }
        
        int capacity = sum / 2;
        boolean[] dp = new boolean[capacity + 1];
        
        dp[0] = true;
        for (int j = 1; j <= nums.length; j++) {
            for (int i = capacity; i >= 0; i--) {
                if (nums[j - 1] <= i) {
                    dp[i] = dp[i - nums[j - 1]] || dp[i];
                } 
            }
        }
        
        return dp[capacity];
        
    }
}

Regular Expression Matching 

正则表达式匹配

思路：是一道双序列型动态规划，注意方程与通配符匹配的不同之处。

public class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length(), n = p.length();
        char[] ws = s.toCharArray();
        char[] wp = p.toCharArray();
        boolean[][] dp = new boolean[m+1][n+1];
        
        dp[0][0] = true;
        if (m > 0 && n > 0) {
            dp[1][1] = wp[0] == '.' || wp[0] == ws[0];
        }
        
        for (int j = 1; j <= n; j++) {
            if (wp[j - 1] == '*') {
                dp[0][j] = j == 1 ? true : dp[0][j - 2] || dp[0][j - 1];
            } 
        }
        for (int i = 1; i <= m; i++) {
            dp[i][0] = false;
        }
        
        for (int i = 1; i <= m; i++) {
            for (int j = 2; j <= n; j++) {
                if (wp[j-1] == '.' || ws[i-1] == wp[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                } else if (wp[j-1] == '*') {
                    if (wp[j-2] == '*') {
                        dp[i][j] = dp[i][j-1];
                    } else {
                        dp[i][j] = dp[i][j-2];
                        if (wp[j-2] == ws[i-1] || wp[j-2] == '.') {
                            dp[i][j] |= dp[i-1][j];
                        }
                    }
                }
            }
        }
        return dp[m][n];
    }
}

Word Break II

切分单词II

思路：用wordbreak I 动态规划的结果，来为搜索做剪枝，避免不必要的搜索，保留isWord[i][j]数组可以避免每次重复的切割字符串。如果用动态规划中保留中间结果的方法会超时，因为保留了很多不必要的中间结果，而保留中间结果既耗时又耗空间。

public class Solution {
    /**
     * @param s a string
     * @param wordDict a set of words
     */
    public List<String> wordBreak(String s, Set<String> wordDict) {
        // Write your code here
        boolean[] dp = new boolean[s.length() + 1];
        
        int maxLen = 0;
        for (String word : wordDict) {
            maxLen = Math.max(word.length(), maxLen);
        }
        
        boolean[][] isWord = new boolean[s.length()][s.length()];
        for (int i = 0; i < s.length(); i++) {
            for (int j = i; j < s.length(); j++) {
                String word = s.substring(i, j + 1);
                isWord[i][j] = wordDict.contains(word);
            }
        }
        
        dp[0] = true;
        
        for (int i = 1; i <= s.length(); i++) {
            for (int j = Math.max(0, i - maxLen); j < i; j++) {
                if (dp[j]) {
                    if (isWord[j][i - 1]) {
                        dp[i] = true;
                        break;
                    }
                }   
            }
        }
        List<String> res = new ArrayList<String>();
        search(res, isWord, dp, s.length() - 1, new ArrayList<String>(), s);
        return res;
    }
    
    public void search(List<String> res, boolean[][] isWord, 
            boolean[] dp, int end, List<String> cur, String s) {
        if (end < 0) {
            StringBuilder sb = new StringBuilder();
            for (int i = cur.size() - 1; i >= 0; i--) {
                sb.append(cur.get(i));
                if (i != 0) {
                    sb.append(" ");
                }
            }
            res.add(sb.toString());
        }
        
        for (int i = end; i >= 0; i--) {
            if (isWord[i][end] && dp[i]) {
                cur.add(s.substring(i, end + 1));
                search(res, isWord, dp, i - 1, cur, s);
                cur.remove(cur.size() - 1);
            }
        }
    }
}

Wildcard Matching

通配符匹配

思路：属于双序列型动态规划，（注意题目中假设了只有p中含有通配符）。

　　　状态：dp[i][j]表示s的前i个字符组成的前缀串与p的前j个字符组成的前缀串是否匹配。

　　　方程：判断两个字符串是否匹配，有两种情况：

　　　　　　1 p的最后一个字母不为'*'，则要求最后一个字母匹配（相等或其中一个字母为'?'），且前i-1字串与前j-1字串匹配；

　　　　　　2 p的最后一个字母为'*'，如果它匹配s的最后一个空字符串，则等价于看dp[i][j-1]，如果它匹配s末尾某个非空字符串，则等价于看dp[i-1][j]。

　　　初始化：初始化第0行第0列；

　　　结果：dp[slen][plen]。

public class Solution {
    public boolean isMatch(String s, String p) {
        int m = s.length(), n = p.length();
        char[] ws = s.toCharArray();
        char[] wp = p.toCharArray();
        boolean[][] dp = new boolean[m+1][n+1];
        dp[0][0] = true;
        for (int j = 1; j <= n; j++) {
            dp[0][j] = dp[0][j-1] && wp[j-1] == '*';
        }
        for (int i = 1; i <= m; i++) {
            dp[i][0] = false;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (wp[j-1] == '?' || ws[i-1] == wp[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                }
                else if (wp[j-1] == '*') {
                    dp[i][j] = dp[i-1][j] || dp[i][j-1];
                }
            }
        }
        return dp[m][n];
    }
}