20210224：力扣第229周周赛

题目

1. 1768. 交替合并字符串
         
2. 1769. 移动所有球到每个盒子所需的最小操作数
         
3. 1770. 执行乘法运算的最大分数
         
4. 1771. 由子序列构造的最长回文串的长度
         

思路与算法

1. 前两题不再多说，翻译题意即可
2. 第三题的误区在于我上图红色标出的地方，第三个示例在第三部计算的时候并没有选择更大的-3 1，而是选择了-33，因此想到不能直接进行模拟，需要考虑最大值之间的匹配问题，才可以得到最大的结果。想到使用动态规划来实现，具体状态转移过程以及思路见注释。
3. 第四题是之前的516题的一个延伸题目，只需要在516的基础上增加一个判断条件即可。附上516题的题目如下：
   
   思路为直接动态解决，在此处附上代码：

class Solution {
    public int longestPalindromeSubseq(String s) {
        // 获取长度，创建dp数组
        int n = s.length();
        int[][] f = new int[n][n];
        // f[i][j]表示索引i和j之间的最长回文序列长度，那么显然j>=i，且basecasedp[0][0] = 1;一个字符也是回文序列
        // i从后开始遍历，j从i+1开始遍历，但basecase也要变为f[i][i]= 1
        for (int i = n - 1; i >= 0; i--) {
            f[i][i] = 1;
            for (int j = i + 1; j < n; j++) {
                if (s.charAt(i) == s.charAt(j)) {
                    f[i][j] = f[i + 1][j - 1] + 2;
                } else {
                    f[i][j] = Math.max(f[i + 1][j], f[i][j - 1]);
                }
            }
        }
        return f[0][n - 1];
    }
}

区别在于本题是两个字符串，因此判断时增加两个字符分别在两个字符串即可完成dp

代码实现

1. 1768. 交替合并字符串

class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        string res("");
        // 直接翻译题意即可
        int len1 = word1.size();
        int len2 = word2.size();
        // 判断那个单词短
        int min = len1 <= len2 ? len1 : len2;
        // 进行拼接
        for (int i = 0; i < min; ++i) {
            res += word1[i];
            res += word2[i];
        }
        
        for (int i = min; i < len1; ++i) {
            res += word1[i];
        }
        
        for (int i = min; i < len2; ++i) {
            res += word2[i];
        }
        return res;
    }
};

2. 1769. 移动所有球到每个盒子所需的最小操作数

class Solution {
public:
    vector<int> minOperations(string boxes) {
        vector<int> res;
        // 遍历计算相对距离并填入res即可
        int tmp;
        // k表示当前需要填入res的为第几个值
        for (int k = 0; k < boxes.size(); ++k) {
            tmp = 0;
            for (int i = 0; i < boxes.size(); ++i) {
                if (boxes[i] == '1') {
                    tmp += abs(i-k);
                }
            }
            res.push_back(tmp);
        }
        return res;
    }
};

3. 1770. 执行乘法运算的最大分数

class Solution {
    public int maximumScore(int[] nums, int[] multipliers) {
        int [][] dp = new int[1000 + 5][1000 + 5];
        int len1 = nums.length;
        int len2 = multipliers.length;
        // dp[i][j]表示nums的前面取i个后面取j个时符合题目要求，那么分三种情况处理
        // base case: dp[0][0] = 0;
        // 只从前面取
        for (int i = 1; i <= len2; ++i) {
            dp[i][0] = dp[i - 1][0] + nums[i-1] * multipliers[i - 1];
        }
        // 只从后面取
        for (int i = 1; i <= len2; ++i) {
            dp[0][i] = dp[0][i - 1] + nums[len1 - i] * multipliers[i - 1];
        }
        // 从前面取i个，后面取j个
        for (int i = 1; i <= len2; ++i) {
            for (int j = 1; j + i <= len2; ++j) {
                dp[i][j] = Math.max(dp[i - 1][j] + nums[i - 1] * multipliers[i + j - 1],dp[i][j - 1] + multipliers[i + j - 1] * nums[len1 - j]);
            }
        }
        int res = Integer.MIN_VALUE;
        for (int i = 0; i <= len2; ++i) {
            res = Math.max(dp[i][len2 - i],res);
        }
        return res;
    }
}

4. 1771. 由子序列构造的最长回文串的长度

class Solution {
public:
    int longestPalindrome(string word1, string word2) {
        int res = 0;
        int len1 = word1.size();
        string s = word1 + word2;
        int len = s.size();
        vector<vector<int>> dp(len,vector<int>(len,0));

        for (int i = len - 1; i >= 0; i--) {
            dp[i][i] = 1;
            for (int j = i + 1; j < len; j++) {
                if (s[i] == s[j]) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                    // 在此处与516题有区别，保证两个字符刚好在两个字符串中
                    if (i < len1 && j >= len1) {
                        res = max(res, dp[i][j]);
                    }
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return res;
    }
    
};

写在最后

1. 冲！