Codeforces Round 991 div3 个人题解(A~G)
Codeforces Round 991 div3 个人题解(A~G)
Dashboard - Codeforces Round 991 (Div. 3) - Codeforces
A. Line Breaks
科斯佳有一个由 \(n\) 个拉丁字母组成的文字 \(s\)。他还必须在两张纸条上书写文字。第一张纸条可以容纳 \(m\) 个字符，而第二张纸条可以容纳尽可能多的字符。
科斯佳必须选择一个数字 \(x\)，并在第一条上写下 \(s\) 中的第一个 \(x\) 字，而其余所有字都写在第二条上。为了节省空间，单词的书写不留空隙，但每个单词必须完全写在一张纸条上。
由于第二条上的空间非常宝贵，科斯佳要求你选择最大可能的数字 \(x\)，使所有单词 \(s_1, s_2, \ldots, s_x\) 都能写在长度为 \(m\) 的第一条上。
输入
第一行包含一个整数 \(t\) \((1 \leq t \leq 1000)\) — 测试用例的数量。
每个测试用例的第一行包含两个整数 \(n\) 和 \(m\) \((1 \leq n \leq 50; 1 \leq m \leq 500)\) — 列表中的单词数量和第一条纸条上可以放置的最大字符数。
接下来的 \(n\) 行包含一个单词 \(s_i\)（由小写拉丁字母组成），其中 \(s_i\) 的长度不超过 \(10\)。
输出
对于每个测试用例，输出最大字数 \(x\)，使得前 \(x\) 个字的总长度不超过 \(m\)。
示例
输入
5
3 1
a
b
c
2 9
alpha
beta
4 12
hello
world
and
codeforces
3 2
ab
c
d
3 2
abc
ab
a
输出
1
2
2
1
0
解题思路
按照题目意思模拟，累加字符串长度直到大于 \(m\) 即可。
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
int n, m;
cin >> n >> m;
int sum = 0;
vector<string> v(n);
for (int i = 0; i < n; i++)
{
cin >> v[i];
}
for (int i = 0; i < n; i++)
{
if (sum + v[i].length() <= m)
{
sum += v[i].length();
}
else
{
cout << i << "\n";
return;
}
}
cout << n << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
B. Transfusion
给你一个长度为 \(n\) 的数组 \(a\)。在一次操作中，你可以从 \(2\) 到 \(n-1\)（含）之间选取索引 \(i\)，并执行以下操作之一：
- 将 \(a_{i-1}\) 减少 \(1\)，然后将 \(a_{i+1}\) 增加 \(1\)。
- 将 \(a_{i+1}\) 减少 \(1\)，然后将 \(a_{i-1}\) 增加 \(1\)。
每次运算后，所有数值都必须为非负。你能在任意多次运算后使所有元素相等吗？
输入
第一行输入包括一个整数 \(t\) \((1 \leq t \leq 10^4)\) - 测试用例数。
每个测试用例的第一行由一个整数 \(n\) \((3 \leq n \leq 2 \cdot 10^5)\) 组成。
每个测试用例的第二行由 \(n\) 个整数 \(a_i\) \((1 \leq a_i \leq 10^9)\) 组成。
保证所有测试用例的 \(n\) 之和不超过 \(2 \cdot 10^5\)。
输出
对于每个测试用例，如果经过任意次数的运算后可以使所有元素相等，则打印 "YES"（不带引号）；否则，打印 "NO"（不带引号）。
您可以用任何寄存器打印答案："yes"、"YeS"、"nO" - 也会被认为是正确的。
示例
输入
8
3
3 2 1
3
1 1 3
4
1 2 5 4
4
1 6 6 1
5
6 2 1 4 2
4
1 4 2 1
5
3 1 2 1 3
3
2 4 2
输出
YES
NO
YES
NO
YES
NO
NO
NO
解题思路
我们只能同时操作奇数或偶数下标，且+1 -1不改变总值，因此将所有间隔为 \(1\) 的值相加，检查它们之和是否为数量的倍数且平均数相等即可。
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
int n;
cin >> n;
vl a(n);
ll sum1 = 0;
ll sum2 = 0;
ll cnt1 = 0;
ll cnt2 = 0;
for (int i = 0; i < n; i++)
{
cin >> a[i];
if (i & 1)
sum1 += a[i], cnt1++;
else
sum2 += a[i], cnt2++;
}
if (n == 1)
{
cout << "YES\n";
}
if (sum1 % cnt1 || sum2 % cnt2 || sum1 / cnt1 != sum2 / cnt2)
{
cout << "NO\n";
}
else
{
cout << "YES\n";
}
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
C. Uninteresting Number
给你一个长度不超过 \(10^5\) 的数字 \(n\)。
你可以多次进行下面的运算：选择其中一位数字，将其平方，然后用运算结果替换原来的数字。结果必须是一位数字（也就是说，如果您选择数字 \(x\)，那么 \(x^2\) 的值必须小于 \(10\)）。
通过这些运算，有可能得到一个能被 \(9\) 整除的数吗？
输入
第一行包含一个整数 \(t\) \((1 \leq t \leq 10^4)\) - 测试用例的数量。
每个测试用例的唯一一行包含数字 \(n\)，不含前导零。数字长度不超过 \(10^5\)。
保证所有测试用例的数字长度之和不超过 \(10^5\)。
输出
对于每个测试用例，如果可以通过所述操作得到一个能被 \(9\) 整除的数，则输出 "YES"，否则输出 "NO"。
您可以以任何大小写（小写或大写）输出每个字母。例如，字符串 "yEs"、"yes"、"Yes" 和 "YES" 将被视为肯定答案。
示例
输入
9
123
322
333333333333
9997
5472778912773
1234567890
23
33
52254522632
输出
NO
YES
YES
NO
NO
YES
NO
YES
YES
注意
在第一个示例中，从整数 \(123\)，只能得到 \(123\)、\(143\)、\(129\) 和 \(149\)，其中没有一个能被 \(9\) 整除。
在第二个示例中，你需要将第二个数字替换为它的平方；然后 \(n\) 将等于 \(342=38 \cdot 9\)。
在第三个示例中，整数已经能被 \(9\) 整除。
解题思路
由小学数学知识可知 \(9\) 的倍数的各数位之和也为 \(9\) 的倍数。观察发现，只有 \(2\) 和 \(3\) 平方后会对数位之后有影响。
因此，我们统计一下 \(2\) 和 \(3\) 的数量，然计算一下数位之和，算出它与最近的 \(9\) 的倍数的差值 \(r\) ，如果 \(r\) 为奇数的话我们记得要 加 \(9\) ，因为我们不管是给 \(2\) 平方 还是给 \(3\) 平方都只能对数位和增加偶数。
然后优先给 \(3\) 平方，看剩下的值是否能用 \(2\) 平方凑出来即可。
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
string s;
cin >> s;
int cnt2 = 0;
int cnt3 = 0;
int sum = 0;
for (auto c : s)
{
if (c == '2')
cnt2++;
else if (c == '3')
cnt3++;
sum += (c - '0');
}
int r = (9 - sum % 9);
if (r == 9)
{
cout << "YES" << "\n";
return;
}
// cout << sum << "\n";
if (r & 1)
r += 9;
r -= min(cnt3, (r / 6)) * 6;
// cout << r << "\n";
int need = r / 2;
if (cnt2 >= need)
cout << "YES" << "\n";
else
cout << "NO" << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
D. Digital string maximization
给你一个字符串 \(s\)，由从 \(0\) 到 \(9\) 的数字组成。在一次运算中，您可以选取该字符串中除 \(0\) 或最左边数字之外的任意一个数字，将其减少 \(1\)，然后将其与左边的数字对调。
例如，从字符串 \(1023\) 中进行一次运算，可以得到 \(1103\) 或 \(1022\)。
找出任意多次运算后可以得到的词序最大字符串。
输入
输入的第一行是一个整数 \(t\) \((1 \leq t \leq 10^4)\) - 测试用例的数量。
每个测试用例由一行数字字符串 \(s\) \((1 \leq |s| \leq 2 \cdot 10^5)\) 组成，其中 \(|s|\) 表示 \(s\) 的长度。
保证所有测试用例的 \(|s|\) 之和不超过 \(2 \cdot 10^5\)。
输出
对于每个测试用例，在单独的一行中打印答案。
示例
输入
6
19
1709
11555
51476
9876543210
5891917899
输出
81
6710
33311
55431
9876543210
7875567711
注意
在第一个示例中，以下操作序列是合适的：\(19 \rightarrow 81\)。
在第二个示例中，以下操作序列是合适的：\(1709 \rightarrow 1780 \rightarrow 6180 \rightarrow 6710\)。
在第四个示例中，以下操作序列是合适的：\(51476 \rightarrow 53176 \rightarrow 53616 \rightarrow 53651 \rightarrow 55351 \rightarrow 55431\)。
解题思路
由于题目限定了所有测试用例的 \(|s|\) 之和不超过 \(2 \cdot 10^5\) ，因此我们直接对每一位数进行模拟，向后找10位，贪心的把换过来最大的数换过来即可，时间复杂度为 \(20n\) 。
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++)
{
string t = s.substr(i, min(10, n - i));
int mx = s[i] - '0';
int pos = 0;
for (int j = 0; j < t.size(); j++)
{
if (t[j] - '0' - j > mx)
{
mx = t[j] - '0' - j;
pos = j;
}
}
s[i] = mx + '0';
for (int j = 0, k = 1; j < t.size(), k < t.size(); j++)
{
if (j == pos)
continue;
s[i + k] = t[j];
k++;
}
}
cout << s << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
E. Three Strings
给您三个字符串：\(a\)、\(b\) 和 \(c\)，由小写拉丁字母组成。字符串 \(c\) 是通过以下方法得到的：
每一步都随机选择字符串 \(a\) 或字符串 \(b\)，并将所选字符串的第一个字符从中删除，然后添加到字符串 \(c\) 的末尾，直到其中一个字符串用完为止。之后，将非空字符串的剩余字符添加到 \(c\) 的末尾。然后，随机更改字符串 \(c\) 中的一定数量字符。
例如，从字符串 \(a=\text{abra}\) 和 \(b=\text{cada}\) 中，在不替换字符的情况下，可以得到字符串 \(\text{caabdraa}\)、\(\text{abracada}\)、\(\text{acadabra}\)。
求字符串 \(c\) 中最少可以替换的字符数。
输入
输入的第一行包含一个整数 \(t\) \((1 \leq t \leq 10^3)\) - 测试用例的数量。
每个测试用例的第一行包含一个拉丁字母小写字符串 \(a\) \((1 \leq |a| \leq 10^3)\) - 第一个字符串，其中 \(|a|\) 表示字符串 \(a\) 的长度。
每个测试用例的第二行包含一个小写拉丁字母字符串 \(b\) \((1 \leq |b| \leq 10^3)\) - 第二字符串，其中 \(|b|\) 表示字符串 \(b\) 的长度。
每个测试用例的第三行包含一串拉丁小写字母 \(c\) \((|c|=|a|+|b|)\) - 第三字符串。
保证所有测试用例中 \(|a|\) 的总和不超过 \(2 \cdot 10^3\)。同时，所有测试用例中 \(|b|\) 的总和不超过 \(2 \cdot 10^3\)。
输出
针对每个测试用例，输出一个整数 - 字符串 \(c\) 中可能被更改的最少字符数。
示例
输入
7
a
b
cb
ab
cd
acbd
ab
ba
aabb
xxx
yyy
xyxyxy
a
bcd
decf
codes
horse
codeforces
egg
annie
egaegaeg
输出
1
0
2
0
3
2
3
15
解题思路
定义 \(dp[i][j]\) 表示使用 \(a\) 的前 \(i\) 个字符和 \(b\) 的前 \(j\) 个字符合并后，与 \(c\) 的前 \(i+j\) 个字符匹配所需的最小修改次数。
如果我们选择从 \(a\) 中取出第 \(i\) 个字符，那么：
\(dp[i][j] = dp[i-1][j] + (a[i-1] != c[i+j-1])\)
如果选择从 \(b\) 中取出第 \(j\) 个字符，那么：
\(dp[i][j] = dp[i][j-1] + (b[j-1] != c[i+j-1])\)
因此状态转移方程为：
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
string a, b, c;
cin >> a >> b >> c;
int na = a.size();
int nb = b.size();
vi f(nb + 1);
for (int j = 1; j <= nb; j++)
{
f[j] = f[j - 1] + (b[j - 1] != c[j - 1]);
}
for (int i = 1; i <= na; i++)
{
vi g(nb + 1);
g[0] = f[0] + (a[i - 1] != c[i - 1]);
for (int j = 1; j <= nb; j++)
{
int idx = i + j - 1;
int costA = f[j] + (a[i - 1] != c[idx]);
int costB = g[j - 1] + (b[j - 1] != c[idx]);
g[j] = min(costA, costB);
}
f.swap(g);
}
cout << f[nb] << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
F. Maximum modulo equality
给你一个长度为 \(n\) 的数组 \(a\) 和 \(q\) 查询 \(l, r\)。
对于每个查询，找出最大可能的 \(m\)，使得所有元素 \(a_l, a_{l+1}, \ldots, a_r\) 都等于模 \(m\)。换句话说，\(a_l \mod m = a_{l+1} \mod m = \cdots = a_r \mod m\)，其中 \(a \mod b\) 是 \(a\) 除以 \(b\) 的余数。特别是当 \(m\) 可以是无限时，打印 \(0\)。
输入
第一行包含一个整数 \(t\) \((1 \leq t \leq 10^4)\) - 测试用例数。
每个测试用例的第一行包含两个整数 \(n, q\) \((1 \leq n, q \leq 2 \cdot 10^5)\) - 数组长度和查询次数。
每个测试用例的第二行包含 \(n\) 个整数 \(a_i\) \((1 \leq a_i \leq 10^9)\) - 数组的元素。
在每个测试用例的后续 \(q\) 行中，提供了两个整数 \(l, r\) \((1 \leq l \leq r \leq n)\) - 查询范围。
保证所有测试用例中 \(n\) 的总和不超过 \(2 \cdot 10^5\)，\(q\) 的总和不超过 \(2 \cdot 10^5\)。
输出
对于每个查询，输出语句中描述的最大值 \(m\)。
示例
输入
3
5 5
5 14 2 6 3
4 5
1 4
2 4
3 5
1 1
1 1
7
1 1
3 2
1 7 8
2 3
1 2
输出
3 1 4 1 0
0
1 6
注意
在第一个示例的第一个查询中，\(6 \mod 3 = 3 \mod 3 = 0\)。可以证明对于更大的 \(m\)，所需条件将不成立。
在第一个示例的第三个查询中，\(14 \mod 4 = 2 \mod 4 = 6 \mod 4 = 2\)。可以证明对于更大的 \(m\)，所需条件将不成立。
解题思路
对于每个查询区间 \([l, r]\) ，我们需要找到最大的 \(m\)，满足条件：\(a_l \mod m = a_{l+1} \mod m = \cdots = a_r \mod m\)
根据同余的性质，若所有元素对 \(m\) 取余相同，则任意两个元素的差都能被 \(m\) 整除。因此，\(m\) 必须是区间内所有元素两两差值的最大公约数 \(\text{GCD}\)。即
因此，我们先计算出可以 \(a\) 的差分数组，然后使用ST表或者线段树维护区间GCD即可
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
const int N = 2e5 + 5;
const int LGN = 20;
int LOG2[N];
void getLog()
{
LOG2[1] = 0;
for (int i = 2; i < N; i++)
{
LOG2[i] = LOG2[i / 2] + 1;
}
}
void solve()
{
int n, q;
cin >> n >> q;
vl a(n);
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
int m = n - 1;
vl d(m);
for (int i = 0; i < m; i++)
{
d[i] = abs(a[i + 1] - a[i]);
}
vector<vl> st;
int K = 0;
if (m > 0)
{
K = LOG2[m] + 1;
st.assign(m, vl(K));
for (int i = 0; i < m; i++)
{
st[i][0] = d[i];
}
for (int j = 1; j < K; j++)
{
for (int i = 0; i + (1 << j) <= m; i++)
{
st[i][j] = gcd(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
}
vl ans;
while (q--)
{
int l, r;
cin >> l >> r;
if (l == r)
{
ans.push_back(0);
continue;
}
int L = l - 1;
int R = r - 2;
int length = R - L + 1;
int k = LOG2[length];
ll res = gcd(st[L][k], st[R - (1 << k) + 1][k]);
ans.push_back(res == 0 ? 0 : res);
}
for (int i = 0; i < ans.size(); i++)
{
cout << ans[i] << " ";
}
cout << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
getLog();
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
G. Tree Destruction
给定一棵有 \(n\) 个顶点的树∗。您可以选择两个顶点 \(a\) 和 \(b\) 一次，然后删除从 \(a\) 到 \(b\) 的路径上的所有顶点，包括顶点本身。如果您选择 \(a=b\)，则只会删除一个顶点。
你的任务是找出从树中移除路径后所能形成的最大连通组件数†。
∗ 树是一个没有循环的连通图。
† 一个连通部分是这样一个顶点集合：从任意顶点到集合中的任意其他顶点都有一条沿着边的路径（并且不可能到达不属于这个集合的顶点）。
输入
输入的第一行包含一个整数 \(t\) \((1 \leq t \leq 10^4)\) - 测试用例的数量。
每个测试用例的第一行包含一个整数 \(n\) \((2 \leq n \leq 2 \cdot 10^5)\) - 树的大小。
接下来的 \(n-1\) 行包含两个整数 \(u\) 和 \(v\) \((1 \leq u, v \leq n, u \neq v)\) - 由一条边连接的顶点。可以保证这些边构成一棵树。
保证所有测试用例中 \(n\) 的总和不超过 \(2 \cdot 10^5\)。
输出
对于每个测试用例，输出一个整数 - 使用所述操作可实现的最大连接组件数。
示例
输入
6
2
1 2
5
1 2
2 3
3 4
3 5
4
1 2
2 3
3 4
5
2 1
3 1
4 1
5 4
6
2 1
3 1
4 1
5 3
6 3
6
2 1
3 2
4 2
5 3
6 4
输出
1
3
2
3
4
3
解题思路
观察发现，移除路径上的每个节点会断开其附属的子树。
因此我们需要选择一条路径，使得路径上的节点具有尽可能多的子树，从而最大化移除后形成的连通分量数量。
简单模拟可得
-
对于路径上的每个节点，其贡献的连通分量数量为 \(deg[u] - 2\)，其中 \(deg[u]\) 是节点的度数。
-
对于路径的端点，贡献为 \(deg[u] - 1\)
因此，目标转化为在树中找到一条路径，使得路径上所有节点的 \(deg[u] - 2\) 之和最大。最终的连通分量数量为这个和加上2。
我们可以使用DFS遍历树，计算每条路径的 \(deg[u] - 2)\) 之和。
题解代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
int n;
cin >> n;
vector<vi> adj(n + 1);
vi deg(n + 1, 0);
for (int i = 1; i < n; i++)
{
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
deg[u]++;
deg[v]++;
}
vl val(n + 1);
for (int i = 1; i <= n; i++)
{
val[i] = deg[i] - 2;
}
ll ans = -infll;
auto dfs = [&](auto &self, int u, int fa) -> ll
{
vl sums;
for (auto &v : adj[u])
{
if (v == fa)
continue;
ll sum = self(self, v, u);
if (sum > 0)
sums.push_back(sum);
}
sort(sums.begin(), sums.end(), greater<ll>());
ll now = val[u];
if (!sums.empty())
now += sums[0];
ll tot = val[u];
if (sums.size() >= 2)
tot += sums[0] + sums[1];
else if (sums.size() == 1)
tot += sums[0];
ans = max(ans, tot);
ans = max(ans, now);
return now;
};
dfs(dfs, 1, 0);
ll res = ans + 2;
cout << res << "\n";
}
int main()
{
ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int _ = 1;
std::cin >> _;
while (_--)
{
solve();
}
return 0;
}
/*######################################END######################################*/
// 链接：
这场题目好典啊，感觉比平常d3简单半个档次
封面画师id：竜崎いち - pixiv
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 地球OL攻略 —— 某应届生求职总结
· 周边上新：园子的第一款马克杯温暖上架
· Open-Sora 2.0 重磅开源！
· 提示词工程——AI应用必不可少的技术
· .NET周刊【3月第1期 2025-03-02】