Leetcode 第243场周赛 创新奇智&力扣
本次差点全AC了，还是差一点火候。
第一题-字符串中不同整数的数目
给你一个字符串 word ，该字符串由数字和小写英文字母组成。
请你用空格替换每个不是数字的字符。例如，“a123bc34d8ef34” 将会变成 " 123 34 8 34" 。注意，剩下的这些整数间至少要用一个空格隔开：“123”、“34”、“8” 和 “34” 。
返回对 word 完成替换后形成的 不同 整数的数目。
如果两个整数的 不含前导零 的十进制表示不同，则认为这两个整数也不同。
示例一：
1
2
3
| 输入：word = "a123bc34d8ef34"
输出：3
解释：不同的整数有 "123"、"34" 和 "8" 。注意，"34" 只计数一次。
|
示例二
1
2
| 输入：word = "leet1234code234"
输出：2
|
示例三
1
2
3
| 输入：word = "a1b01c001"
输出：1
解释："1"、"01" 和 "001" 视为同一个整数的十进制表示，因为在比较十进制值时会忽略前导零的存在。
|
提示：
1 <= word.length <= 1000
word 由数字和小写英文字母组成
该题只需要考虑两个东西，第一是提取数字，第二是去重。
利用vector提取数字，set去重
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| class Solution {
public:
int numDifferentIntegers(string word) {
int n = word.length();
set<string> s;
for (int i = 0; i < n; i++)
{
if (word[i] >= '0'&&word[i] <= '9')
{
vector<char> vc;
while (i < n && (word[i] >= '0'&&word[i] <= '9'))
{
vc.push_back(word[i++]);
}
while (vc.size() > 1 && vc[0] == '0')
{
vc.erase(vc.begin());
}
string tmp = "";
for (auto x : vc)
tmp += x;
s.insert(tmp);
}
}
return s.size();
}
};
|
第二题-还原排列的最少操作步数
给你一个偶数 n ，已知存在一个长度为 n 的排列 perm ，其中 perm[i] == i（下标 从 0 开始 计数）。
一步操作中，你将创建一个新数组 arr ，对于每个 i ：
如果 i % 2 == 0 ，那么 arr[i] = perm[i / 2]
如果 i % 2 == 1 ，那么 arr[i] = perm[n / 2 + (i - 1) / 2]
然后将 arr 赋值给 perm 。
要想使 perm 回到排列初始值，至少需要执行多少步操作？返回最小的 非零 操作步数。
示例一：
1
2
3
4
5
| 输入：n = 2
输出：1
解释：最初，perm = [0,1]
第 1 步操作后，perm = [0,1]
所以，仅需执行 1 步操作
|
示例二:
1
2
3
4
5
6
| 输入：n = 4
输出：2
解释：最初，perm = [0,1,2,3]
第 1 步操作后，perm = [0,2,1,3]
第 2 步操作后，perm = [0,1,2,3]
所以，仅需执行 2 步操作
|
示例三:
提示：
2 <= n <= 1000
n 是一个偶数
我们只用考虑arr数组是否对应prem[i] = i 即可，否则则操作步数+1。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| class Solution {
public:
int reinitializePermutation(int n) {
int cnt = 0;
int j = 0;
vector<int> arr(n);
vector<int> prem(n);
for (int i = 0; i < n; i++)
prem[i] = i;
while (j<n)
{
for (int i = 0; i < n; i++)
{
if (i%2==0)arr[i] = prem[i/2];
else arr[i] = prem[n / 2 + (i -1)/ 2 ];
}
prem = arr;
for (j = 0; j < n; j++)
{
if (prem[j] != j)
{
cnt++;
break;
}
}
if (j == n)return cnt+1;
}
return 0;
}
};
|
第三题-替换字符串中的括号内容
给你一个字符串 s ，它包含一些括号对，每个括号中包含一个 非空 的键。
比方说，字符串 “(name)is(age)yearsold” 中，有 两个 括号对，分别包含键 “name” 和 “age” 。
你知道许多键对应的值，这些关系由二维字符串数组 knowledge 表示，其中 knowledge[i] = [keyi, valuei] ，表示键 keyi 对应的值为 valuei 。
你需要替换 所有 的括号对。当你替换一个括号对，且它包含的键为 keyi 时，你需要：
将 keyi 和括号用对应的值 valuei 替换。
如果从 knowledge 中无法得知某个键对应的值，你需要将 keyi 和括号用问号 “?” 替换（不需要引号）。
knowledge 中每个键最多只会出现一次。s 中不会有嵌套的括号。
请你返回替换 所有 括号对后的结果字符串。
示例一：
1
2
3
4
5
| 输入：s = "(name)is(age)yearsold", knowledge = [["name","bob"],["age","two"]]
输出："bobistwoyearsold"
解释：
键 "name" 对应的值为 "bob" ，所以将 "(name)" 替换为 "bob" 。
键 "age" 对应的值为 "two" ，所以将 "(age)" 替换为 "two" 。
|
示例二：
1
2
3
| 输入：s = "hi(name)", knowledge = [["a","b"]]
输出："hi?"
解释：由于不知道键 "name" 对应的值，所以用 "?" 替换 "(name)" 。
|
示例三：
1
2
3
4
5
| 输入：s = "(a)(a)(a)aaa", knowledge = [["a","yes"]]
输出："yesyesyesaaa"
解释：相同的键在 s 中可能会出现多次。
键 "a" 对应的值为 "yes" ，所以将所有的 "(a)" 替换为 "yes" 。
注意，不在括号里的 "a" 不需要被替换。
|
看到找对应值的题，首先想到了map,然后题意告诉了我们并不需要保持map有序，所以使用unordered_map,将knowledge的值提取出来放入map,然后判断括号内的内容，找到了则替换成unordered_map[key],没找到则替换成‘？’.然后使用一个字符串保存所有结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| class Solution {
public:
string evaluate(string s, vector<vector<string>>& knowledge) {
unordered_map<string,string> maps;
string res = "";
for(vector<string> x : knowledge)
{
maps[x[0]] = x[1];
}
int ssize = s.length();
for(int i = 0 ; i < ssize ; i++)
{
if(s[i] == '(')
{
string tmp = "";
i++;
while(s[i]!=')')
{
tmp += s[i++];
}
if(maps.find(tmp)!=maps.end())
{
res+=maps[tmp];
continue;
}
else
{
res+='?';
}
continue;
}
res+=s[i];
}
return res;
}
};
|
第四题-好因子的最大数目
时间不够没写出来，但看上去只需要维持一个素数表，利用空间换取时间，然后做到因数拆分就行了，对其因数加以判断就行了，需要注意的应该就是值太大要利用快速幂取模。
附上大佬题解：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| class Solution
{
public:
int maxNiceDivisors(int primeFactors)
{
long long n = primeFactors;
if (n <= 4)
return n;
long long tmp = n / 3;
if (n % 3 == 0)
return f(3, tmp) % 1000000007;
else if (n % 3 == 1)
return f(3, tmp-1) * 4 % 1000000007;
else
return f(3, tmp) * 2 % 1000000007;
}
long long f(long long a, long long n)
{
long long res = 1;
while(n > 0)
{
if (n & 1)
{
res *= a;
res %= 1000000007;
}
a *= a;
a %= 1000000007;
n /= 2;
}
return res;
}
};
|
