本文已参与「新人创作礼」活动，一起开启掘金创作之路。
6180. 最小偶倍数
给你一个正整数 n ，返回 2 和 n 的最小公倍数（正整数）。
示例 1：
输入：n = 5
输出：10
解释：5 和 2 的最小公倍数是 10 。
示例 2：
输入：n = 6
输出：6
解释：6 和 2 的最小公倍数是 6 。注意数字会是它自身的倍数。
提示：
1 <= n <= 150
思路
最小公倍数
代码
class Solution {
public:
int smallestEvenMultiple(int n) {
return n * 2 / __gcd(n, 2);
}
};
6181. 最长的字母序连续子字符串的长度
字母序连续字符串 是由字母表中连续字母组成的字符串。换句话说，字符串 "abcdefghijklmnopqrstuvwxyz" 的任意子字符串都是 字母序连续字符串 。
例如，"abc" 是一个字母序连续字符串，而 "acb" 和 "za" 不是。 给你一个仅由小写英文字母组成的字符串 s ，返回其 最长 的 字母序连续子字符串 的长度。
示例 1：
输入：s = "abacaba"
输出：2
解释：共有 4 个不同的字母序连续子字符串 "a"、"b"、"c" 和 "ab" 。
"ab" 是最长的字母序连续子字符串。
示例 2：
输入：s = "abcde"
输出：5
解释："abcde" 是最长的字母序连续子字符串。
提示：
1 <= s.length <= 105
s 由小写英文字母组成
思路
顺序遍历 条件判断
代码
class Solution {
public:
int longestContinuousSubstring(string s) {
int ans = 1, now = 1;
for (int i = 1; i < s.size(); i ++) {
if (s[i] != s[i-1] + 1) ans = max(ans, now), now = 1;
else now ++;
}
ans = max(ans, now);
return ans;
}
};
6182. 反转二叉树的奇数层
给你一棵 完美 二叉树的根节点 root ，请你反转这棵树中每个 奇数 层的节点值。
例如，假设第 3 层的节点值是 [2,1,3,4,7,11,29,18] ，那么反转后它应该变成 [18,29,11,7,4,3,1,2] 。 反转后，返回树的根节点。
完美 二叉树需满足：二叉树的所有父节点都有两个子节点，且所有叶子节点都在同一层。
节点的 层数 等于该节点到根节点之间的边数。
示例 1：
输入：root = [2,3,5,8,13,21,34]
输出：[2,5,3,8,13,21,34]
解释：
这棵树只有一个奇数层。
在第 1 层的节点分别是 3、5 ，反转后为 5、3 。
示例 2：
输入：root = [7,13,11]
输出：[7,11,13]
解释：
在第 1 层的节点分别是 13、11 ，反转后为 11、13 。
示例 3：
输入：root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
输出：[0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
解释：奇数层由非零值组成。
在第 1 层的节点分别是 1、2 ，反转后为 2、1 。
在第 3 层的节点分别是 1、1、1、1、2、2、2、2 ，反转后为 2、2、2、2、1、1、1、1 。
思路
利用 bfs 每次把下一层的元素取出来，顺便看是不是需要反转当前层的元素
用一个数组来存储反转的元素即可
代码
class Solution {
public:
TreeNode* reverseOddLevels(TreeNode* root) {
queue<TreeNode*> que;
que.push(root);
for (int i = 1; que.size(); i ++) {
queue<TreeNode*> tmp;
vector<int> ve;
vector<TreeNode*> node;
while (que.size()) {
auto t = que.front(); que.pop();
if (t->left) tmp.push(t->left);
if (t->right) tmp.push(t->right);
node.push_back(t);
ve.push_back(t->val);
}
if (i % 2 == 0) {
reverse(begin(ve), end(ve));
for (int i = 0; i < ve.size(); i ++) node[i]->val = ve[i];
}
que = tmp;
}
return root;
}
};
6183. 字符串的前缀分数和
给你一个长度为 n 的数组 words ，该数组由 非空 字符串组成。
定义字符串 word 的 分数 等于以 word 作为 前缀 的 words[i] 的数目。
例如，如果 words = ["a", "ab", "abc", "cab"] ，那么 "ab" 的分数是 2 ，因为 "ab" 是 "ab" 和 "abc" 的一个前缀。 返回一个长度为 n 的数组 answer ，其中 answer[i] 是 words[i] 的每个非空前缀的分数 总和 。
注意：字符串视作它自身的一个前缀。
示例 1：
输入：words = ["abc","ab","bc","b"]
输出：[5,4,3,2]
解释：对应每个字符串的答案如下：
- "abc" 有 3 个前缀："a"、"ab" 和 "abc" 。
- 2 个字符串的前缀为 "a" ，2 个字符串的前缀为 "ab" ，1 个字符串的前缀为 "abc" 。
总计 answer[0] = 2 + 2 + 1 = 5 。
- "ab" 有 2 个前缀："a" 和 "ab" 。
- 2 个字符串的前缀为 "a" ，2 个字符串的前缀为 "ab" 。
总计 answer[1] = 2 + 2 = 4 。
- "bc" 有 2 个前缀："b" 和 "bc" 。
- 2 个字符串的前缀为 "b" ，1 个字符串的前缀为 "bc" 。
总计 answer[2] = 2 + 1 = 3 。
- "b" 有 1 个前缀："b"。
- 2 个字符串的前缀为 "b" 。
总计 answer[3] = 2 。
示例 2：
输入：words = ["abcd"]
输出：[4]
解释：
"abcd" 有 4 个前缀 "a"、"ab"、"abc" 和 "abcd"。
每个前缀的分数都是 1 ，总计 answer[0] = 1 + 1 + 1 + 1 = 4 。
提示：
1 <= words.length <= 1000
1 <= words[i].length <= 1000
words[i] 由小写英文字母组成
思路
trie 树模板题
只需要你改一下cnt存储的方式
在存放树的时候，在每一层都记录一下以当前结尾的子字符串有多少个
然后在查询时累加即可
代码
class Solution {
public:
static const int N = 1111 * 26 * 26;
vector<int> sumPrefixScores(vector<string>& words) {
int tr[N][26] = {0}, idx = 0, con[N] = {0};
auto insert = [&](string s) {
int p = 0;
for (auto v : s) {
int ch = v - 'a';
if (!tr[p][ch]) tr[p][ch] = ++ idx;
p = tr[p][ch];
con[p] ++;
}
};
auto cala = [&](string s) -> int {
int p = 0, res = 0;
for (auto v : s) {
int ch = v - 'a';
if (!tr[p][ch]) break;
p = tr[p][ch];
res += con[p];
}
return res;
};
for (auto v : words) insert(v);
vector<int> ans;
for (auto v : words) ans.push_back(cala(v));
return ans;
}
};
