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

本文链接：https://blog.csdn.net/lingyun_fay/article/details/51694392

　　本篇为其他一些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:

Insert a character
Delete a character
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);
            }
        }
    }