LeetCode刷题系列（十）Dynamic Programming（3）补充

　　本篇为其他一些Dynamic Programming的题型。

Backpack

　　背包问题是典型的动态规划问题，题目是给定若干个元素，每个元素有自己的体积，再给定一个容量为n的背包，将这些元素装进背包中，当然最大只能装进n体积，要求装得越多越好。像这样题型如果使用贪心算法就一定得不到最优的解了。相反，使用动规就很好解决了：f[i][j]表示将i个元素是可以装进容量为j的背包里。然后：

    if (j >= A[i] && f[i][j - A[i]]) {        f[i + 1][j] = true;    }

　　最后的答案一定是在f[A.length][*]上，使用for进行一下搜索找出最小值就好了。

Backpack II

　　这道题目也很典型，继续上道题目，每个元素不仅有自己的体积，并且有自己的价值v，而我们再装包的时候想要装进价值最多的元素（相当于上道题目中，每个元素的价值都为1）。换个思路，我们使用f[i]来保存容量为i时，装进去元素的最大价值，相比与上道题，我们把装进去的元素个数给忽略了（这道题并没有用）。然后对每个容量，我们搜索能装进去的元素，然后取最大的值：

    for(j = m; j >= A[i]; j--){        if (f[j] < f[j - A[i]] + V[i])            f[j] = f[j - A[i]] + V[i];    }

Edit Distance

　　题目：Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

1. Insert a character
2. Delete a character

3. Replace a character

   　　可以从题目中看出，我们可以使用动规比较简单的解决该问题：当word1的第i个字母和word2的第j个字母相等的时候，那么他的替换次数就是word1的第i-1个字母替换成word2的前j-1个字母的次数；当他们不相等时，替换次数为1+Math.min(word1的前i-1个字母替换成word2的前j个字母的次数，word1的前i-1个字母替换成word2的前j-1个字母的次数，word1的前i个字母替换成word2的前j-1个字母的次数)。

   for(int i = 1; i<n+1; i++){    for(int j=1; j<m+1; j++){        if(word1.charAt(i-1) == word2.charAt(j-1)){            dp[i][j] = dp[i-1][j-1];        }else{            dp[i][j] = 1 + Math.min(dp[i-1][j-1],Math.min(dp[i-1][j],dp[i][j-1]));        }    }}

Distinct Subsequences

　题目是给定字符串S、T，求T在S中出现的次数。显 然，我们要使用num[i][j]用来存储S的前i个字母在T的前j个字母中出现的次数。

    for (int i = 1; i <= S.length(); i++) {        for (int j = 1; j <= T.length(); j++) {            nums[i][j] = nums[i - 1][j];            if (S.charAt(i - 1) == T.charAt(j - 1)) {                nums[i][j] += nums[i - 1][j - 1];            }        }    }

Interleaving String

　　题目为求S3是否为S1和S2“混合”而成，S3若是S1的前i个字母和S2
的前j个字母混合的，那么S3一定是i+j个字母，所以我们使用f[i][
j]代表上述情况的是否成立，于是：

for (int i = 1; i <= s1.length(); i++) {        for (int j = 1; j <= s2.length(); j++) {            if(((s3.charAt(i + j - 1) == s1.charAt(i - 1) && interleaved[i - 1][j]))                || ((s3.charAt(i + j - 1)) == s2.charAt(j - 1) && interleaved[i][j - 1]))            interleaved[i][j] = true;        }    }

Minimum Adjustment Cost

　　题目为调整数组中的数，使相邻数之间的差距不超过目标数，求最小的调整代价和（调整代价为调整之后的数与原有数的差值）。这道题是比较能想的动规问题，f[i][k]代表将第i个数替换成k的代价。

public int MinAdjustmentCost(ArrayList<Integer> A, int target) {    // write your code here    int n = A.size();    int[][] f = new int[n + 1][101];    for (int i = 0; i <= n ; ++i)        for (int j = 0; j <=100; ++j)            f[i][j] = 1000000;    for (int i = 0; i <=100; ++i)        f[0][i] = 0;    for (int i = 1; i <=n; ++i)        for (int  j = 0; j <= 100;++j)            if (f[i-1][j] != 1000000)            for (int k = 0; k <= 100; ++k)                if (Math.abs(j-k) <= target)                if (f[i][k] > f[i-1][j] + Math.abs(A.get(i-1)-k))                    f[i][k] = f[i-1][j] + Math.abs(A.get(i-1)-k);      int ans =1000000;    for (int i = 0; i <= 100; ++i)        if (f[n][i] < ans)            ans = f[n][i];    return ans; }

Palindrome Partitioning

　　题目为求给定一个字符串s，将s分割成一些子串，使每个子串都是回文串。返回s所有可能的回文串分割方案。这种返回所有方案的问题是不能使用动规方法解决的，因为动规一般只能储存是否或者数量。那我们就使用递归来解决。类似于第一篇blog中提及的方法。

public ArrayList<ArrayList<String>> partition(String s) {    ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();    if (s == null) {        return result;    }    ArrayList<String> path = new ArrayList<String>();    helper(s, path, 0, result);    return result;}private boolean isPalindrome(String s) {    int beg = 0;    int end = s.length() - 1;    while (beg < end) {        if (s.charAt(beg) != s.charAt(end)) {            return false;        }        beg++;        end--;    }    return true;}private void helper(String s, ArrayList<String> path, int pos,        ArrayList<ArrayList<String>> result) {    if (pos == s.length()) {        result.add(new ArrayList<String>(path));        return;    }    for (int i = pos; i < s.length(); i++) {        String prefix = s.substring(pos, i + 1);        if (!isPalindrome(prefix)) {            continue;        }        path.add(prefix);        helper(s, path, i + 1, result);        path.remove(path.size() - 1);    }}

Palindrome Partitioning II

　　题目基于上一道问题，不同的是我们不是求解决的结果，而是求最小分割的次数，如此我们就可以使用动规来解决了。我们用一个f[i]来表示前i个字母，最少可以被分割为多少个回文串。类似与上道题，我们需要一个isPalindrome函数来检测是否是回文串。如果位置j到i的字符串是回文串，那么f[i]就可以等于f[j] + 1（前j个字符串的最小切割次数），但需要取所有跟j有关方案中的最小值。

    for (int i = 1; i <= s.length(); i++) {        f[i] = Integer.MAX_VALUE; // or f[i] = i        for (int j = 0; j < i; j++) {            if (isPalindrome[j][i - 1]) {                f[i] = Math.min(f[i], f[j] + 1);            }        }    }