文章目录
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
解题：
待学习。状态压缩DP
我的CSDN博客地址 https://michael.blog.csdn.net/
长按或扫码关注我的公众号（Michael阿明），一起加油、一起学习进步！
