leetcode——229场周赛

229场周赛地址

交替合并字符串

给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。

 class Solution {
     
 public:
	 string mergeAlternately(string word1, string word2) {
     
		 string res = "";
		 int size1 = word1.size();
		 int size2 = word2.size();
		 for (int i = 0; i < max(size1, size2); i++)
		 {
     
			 if(i<size1)
			 res += word1[i];
			 if(i<size2)
			 res += word2[i];
		 }
		 return res;
	 }
 };

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

注意以下几点，盒子只有两个状态，0 1。移动只能向左或者向右。那么一个盒子移动到一个距离即为数组下标之差。

class Solution {
     
 public:
	 vector<int> minOperations(string boxes) {
     
		 vector<int> res(boxes.size(), 0);
		 int size = boxes.size();
		 for (int i = 0; i < size; i++)
		 {
     
			 int num = boxes[i] - '0';
			 if (num) {
     
				 for (int j = 0; j < size; j++)
				 {
     
					 res[j] += (abs(j - i) * num);
				 }
			 }
		 }
		 return res;
	 }
 };

执行乘法运算的最大分数

m是10的3次方，所以动态规划。状态转移不太好想。

我们令dp[i][j]为nums数组左边取i个，右边取j个。当i+j==m是，更新答案即可。

枚举取的个数为k，和左边取l个，右边取r=k-l。则左边对应nums下标为l-1，右边为n-r。

则 l==0，全取右边，l ==k全取左边。

 class Solution {
     
 public:
	 typedef long long  ll;
	 int maximumScore(vector<int>& nums, vector<int>& multipliers) {
     
		 vector<vector<ll>>dp(1005, vector<ll>(1005, 0));
		 ll n = nums.size();
		 ll m = multipliers.size();
		 ll res = INT_MIN;
		 for (int k = 1; k <=m; k++)
		 {
     //k为取的总数
			 for (int j = 0; j <= k; j++)
			 {
     
				 int l = j, r = k - j;
				 if (l == 0)dp[l][r] = dp[l][r - 1] + multipliers[k-1] * nums[n - r];
				 else if (l == k) dp[l][r] = dp[l - 1][r] + multipliers[k-1] * nums[l - 1];
				 else dp[l][r] = max(dp[l - 1][r] + multipliers[k-1] * nums[l-1],
					 dp[l][r - 1] + multipliers[k-1] * nums[n - r]);
				 if (k == m) res = max(res, dp[l][r]);
			 }
		 }
		 return res;
	 }
 };

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

与最长回文子串解法差不多，令dp[i][j]为i-j区间内回文串的长度。

有 s[i]==s[j]，dp[i][j]=dp[i+1][j-1]+2。
其他情况下 dp[i][j]=max(dp[i+1][j],dp[i][j-1])。没有回文串则需要两边取最大更新。

需要注意的是，该题中是两个字符串，答案更新条件为i，j分别在两个字符串同时对应字母相等。

 class Solution {
     
 public:
	 int longestPalindrome(string word1, string word2) {
     
		 int size1 = word1.size();
		 int size2 = word2.size();
		 string s = word1 + word2;
		 int len_s = s.size();
		 int res = 0;
		 vector<vector<int>>dp(len_s, vector<int>(len_s));
		 for (int len = 1; len <= len_s; len++)
		 {
     //枚举长度和起点
			 for (int i = 0; i + len - 1 < len_s; i++)
			 {
     
				 int j = i + len - 1;
				 if (len == 1)
					 dp[i][j] = 1;
				 else {
     
					 if (s[i] == s[j])
						 dp[i][j] = dp[i + 1][j - 1] + 2;
					 else dp[i][j] = max(dp[i + 1][j],dp[i][j-1]);
				 }
				 if (dp[i][j] > res&& i < size1 && j >= size1&&s[i]==s[j])
					 res = dp[i][j];
			 }
		 }
		 return res;
	 }
 };