LeetCode 第 207 场周赛（245/4115，前5.95%）

文章目录

- 1. 比赛结果
- 2. 题目
- - 1. LeetCode 5519. 重新排列单词间的空格 easy
  - 2. LeetCode 5520. 拆分字符串使唯一子字符串的数目最大 medium
  - 3. LeetCode 5521. 矩阵的最大非负积 medium
  - 4. LeetCode 5522. 连通两组点的最小成本 hard

1. 比赛结果

做出来3题，第四题试了DP和贪心都没过，状态转移可能没找对。继续加油！

全国排名： 245 / 4115，5.95%；全球排名： 774 / 12923，5.99%

2. 题目

1. LeetCode 5519. 重新排列单词间的空格 easy

题目链接

给你一个字符串 text ，该字符串由若干被空格包围的单词组成。
每个单词由一个或者多个小写英文字母组成，并且两个单词之间至少存在一个空格。

题目测试用例保证 text 至少包含一个单词 。

请你重新排列空格，使每对相邻单词之间的空格数目都相等 ，并尽可能 最大化 该数目。
如果不能重新平均分配所有空格，请将多余的空格放置在字符串末尾，这也意味着返回的字符串应当与原 text 字符串的长度相等。

返回重新排列空格后的字符串。

示例 1：
输入：text = "  this   is  a sentence "
输出："this   is   a   sentence"
解释：总共有 9 个空格和 4 个单词。
可以将 9 个空格平均分配到相邻单词之间，
相邻单词间空格数为：9 / (4-1) = 3 个。示例 2：
输入：text = " practice   makes   perfect"
输出："practice   makes   perfect "
解释：总共有 7 个空格和 3 个单词。
7 / (3-1) = 3 个空格加上 1 个多余的空格。
多余的空格需要放在字符串的末尾。示例 3：
输入：text = "hello   world"
输出："hello   world"示例 4：
输入：text = "  walks  udp package   into  bar a"
输出："walks  udp  package  into  bar  a "示例 5：
输入：text = "a"
输出："a"提示：
1 <= text.length <= 100
text 由小写英文字母和 ' ' 组成
text 中至少包含一个单词

解题：

按题意模拟

class Solution {
public:string reorderSpaces(string text) {int space = 0, word = 0, n = text.length();vector<string> w;string s;for(int i = 0; i < n; i++) {if(text[i] == ' ')space++;//空格计数else{s += text[i];//单词if((i < n-1 && text[i+1] == ' ') || i == n-1){word++;//单词计数w.push_back(s);s = "";}}}if(word == 1)return w[0]+string(space, ' ');int len = space/(word-1);int rest = space - len*(word-1);string ans;string empty(len,' ');for(int i = 0; i < w.size(); i++){ans += w[i];if(i < w.size()-1)ans += empty;}return ans+string(rest, ' ');}
};

4 ms 6.1 MB

2. LeetCode 5520. 拆分字符串使唯一子字符串的数目最大 medium

题目链接

给你一个字符串 s ，请你拆分该字符串，并返回拆分后唯一子字符串的最大数目。

字符串 s 拆分后可以得到若干非空子字符串，这些子字符串连接后应当能够还原为原字符串。
但是拆分出来的每个子字符串都必须是唯一的。

注意：子字符串是字符串中的一个连续字符序列。

示例 1：
输入：s = "ababccc"
输出：5
解释：一种最大拆分方法为 ['a', 'b', 'ab', 'c', 'cc'] 。
像 ['a', 'b', 'a', 'b', 'c', 'cc'] 这样拆分不满足题目要求，
因为其中的 'a' 和 'b' 都出现了不止一次。示例 2：
输入：s = "aba"
输出：2
解释：一种最大拆分方法为 ['a', 'ba'] 。示例 3：
输入：s = "aa"
输出：1
解释：无法进一步拆分字符串。提示：
1 <= s.length <= 16
s 仅包含小写英文字母

解题：

看数据量很小，暴力回溯做的

class Solution {int maxs = 1;unordered_set<string> set;
public:int maxUniqueSplit(string s) {dfs(s, 0);return maxs;}   void dfs(string s, int count){if(s == ""){maxs = max(maxs, count);return;}int n = s.size();for(int len = 1; len <= n; ++len) {string tmp = s.substr(0, len);string rest = s.substr(len);if(set.find(tmp) == set.end())//不重复{set.insert(tmp);//记录下来dfs(rest, count+1);set.erase(tmp);//回溯}}}
};

556 ms 42.1 MB

加入剪枝，加速

class Solution {int maxs = 1;unordered_set<string> set;
public:int maxUniqueSplit(string s) {dfs(s);return maxs;}   void dfs(string s){if(s.size()+set.size() <= maxs)return;//剪枝，剩余的肯定不够大if(s == ""){maxs = max(maxs, int(set.size()));return;}int n = s.size();for(int len = 1; len <= n; ++len) {string tmp = s.substr(0, len);string rest = s.substr(len);if(set.find(tmp) == set.end()){set.insert(tmp);dfs(rest);set.erase(tmp);}}}
};

44 ms 8.7 MB

3. LeetCode 5521. 矩阵的最大非负积 medium

题目链接

给你一个大小为 rows x cols 的矩阵 grid 。
最初，你位于左上角 (0, 0) ，每一步，你可以在矩阵中向右或向下移动。

在从左上角 (0, 0) 开始到右下角 (rows - 1, cols - 1) 结束的所有路径中，找出具有 最大非负积 的路径。
路径的积是沿路径访问的单元格中所有整数的乘积。

返回最大非负积对 10^9 + 7 取余的结果。
如果最大积为负数，则返回 -1 。

注意，取余是在得到最大积之后执行的。

示例 1：
输入：grid = [[-1,-2,-3],[-2,-3,-3],[-3,-3,-2]]
输出：-1
解释：从 (0, 0) 到 (2, 2) 的路径中无法得到非负积，所以返回 -1示例 2：
输入：grid = [[1,-2,1],[1,-2,1],[3,-4,1]]
输出：8
解释：最大非负积对应的路径已经用粗体标出 (1 * 1 * -2 * -4 * 1 = 8)示例 3：
输入：grid = [[1, 3],[0,-4]]
输出：0
解释：最大非负积对应的路径已经用粗体标出 (1 * 0 * -4 = 0)示例 4：
输入：grid = [[ 1, 4,4,0],[-2, 0,0,1],[ 1,-1,1,1]]
输出：2
解释：最大非负积对应的路径已经用粗体标出 (1 * -2 * 1 * -1 * 1 * 1 = 2)提示：
1 <= rows, cols <= 15
-4 <= grid[i][j] <= 4

解题：

动态规划 dp[i][j] 存储一个 pair，first 是最小值，second 是最大值

typedef long long ll;
class Solution {
public:int maxProductPath(vector<vector<int>>& grid) {int m = grid.size(), n = grid[0].size();vector<vector<pair<ll,ll>>> dp(m, vector<pair<ll,ll>>(n));dp[0][0].first = dp[0][0].second =  grid[0][0];// first 存储最小值，second 存储最大值for(int i = 1; i < n; ++i) //初始化第一行,最大最小值都一样{dp[0][i].first = dp[0][i].second = dp[0][i-1].second*grid[0][i];}for(int i = 1; i < m; ++i)  //初始化第一列，最大最小值都一样{dp[i][0].first = dp[i][0].second = dp[i-1][0].second*grid[i][0];}for(int i = 1; i < m; i++){for(int j = 1; j < n; j++){if(grid[i][j] >= 0){dp[i][j].first = min(dp[i-1][j].first, dp[i][j-1].first)*grid[i][j];dp[i][j].second = max(dp[i-1][j].second, dp[i][j-1].second)*grid[i][j];}else// if(grid[i][j] < 0){dp[i][j].second = min(dp[i-1][j].first, dp[i][j-1].first)*grid[i][j];dp[i][j].first = max(dp[i-1][j].second, dp[i][j-1].second)*grid[i][j];}}}if(dp[m-1][n-1].second < 0)return -1;return dp[m-1][n-1].second%(int(1e9+7));}
};

8 ms 10.3 MB

4. LeetCode 5522. 连通两组点的最小成本 hard

题目链接

给你两组点，其中第一组中有 size1 个点，第二组中有 size2 个点，且 size1 >= size2 。

任意两点间的连接成本 cost 由大小为 size1 x size2 矩阵给出，其中 cost[i][j] 是第一组中的点 i 和第二组中的点 j 的连接成本。
如果两个组中的每个点都与另一组中的一个或多个点连接，则称这两组点是连通的。
换言之，第一组中的每个点必须至少与第二组中的一个点连接，
且第二组中的每个点必须至少与第一组中的一个点连接。

返回连通两组点所需的最小成本。

示例 1：

输入：cost = [[15, 96], [36, 2]]
输出：17
解释：连通两组点的最佳方法是：
1--A
2--B
总成本为 17 。

示例 2：

输入：cost = [[1, 3, 5], [4, 1, 1], [1, 5, 3]]
输出：4
解释：连通两组点的最佳方法是：
1--A
2--B
2--C
3--A
最小成本为 4 。
请注意，虽然有多个点连接到第一组中的点 2 和第二组中的点 A ，
但由于题目并不限制连接点的数目，所以只需要关心最低总成本。示例 3：
输入：cost = [[2, 5, 1], [3, 4, 7], [8, 1, 2], [6, 2, 4], [3, 8, 8]]
输出：10提示：
size1 == cost.length
size2 == cost[i].length
1 <= size1, size2 <= 12
size1 >= size2
0 <= cost[i][j] <= 100