A

题解

知识点:贪心。

把所有正偶数除成奇数,即可。

(人傻了没加 \(x>0\) WA2

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
ll ans = 0;
for (int i = 1;i <= n;i++) {
int x;
cin >> x;
while (x > 0 && x % 2 == 0) x /= 2;
ans += x;
}
cout << ans << '\n';
return 0;
}

B

题解

知识点:数学,构造。

特判 \(n=2\) 无解。

可以先放边长为 \(\left\lceil \dfrac{n}{2} \right\rceil\) 正方形,随后边长每增加 \(1\) 需要最少 \(3\) 块,直到边长为 \(2 \cdot \left\lceil \dfrac{n}{2} \right\rceil\) 后,边长每增加 \(1\) 需要最少 \(5\) 块。以此类推,当边长为 \(\left[(k-1)\cdot\left\lceil \dfrac{n}{2} \right\rceil,k\cdot\left\lceil \dfrac{n}{2} \right\rceil \right),k \in \N^+\) 时,边长每增加 \(1\) 需要 \(2k-1\) 块积木。

显然,摆完第一轮边长为 \(\left\lceil \dfrac{n}{2} \right\rceil\) 后,剩下的 \(n - \left\lceil \dfrac{n}{2} \right\rceil\) 个积木,而 \(\left\lfloor \dfrac{n - \left\lceil \dfrac{n}{2} \right\rceil}{3} \right\rfloor \leq \left\lceil \dfrac{n}{2} \right\rceil\) ,因此不可能摆到需要 \(5\) 个积木的情况。

综上,边长最大值为 \(\left\lceil \dfrac{n}{2} \right\rceil + \left\lfloor \dfrac{n - \left\lceil \dfrac{n}{2} \right\rceil}{3} \right\rfloor\) 。

本题也可以用二分边长做。

(没考虑 \(n - \left\lceil \dfrac{n}{2} \right\rceil\) 大小,傻了吧唧的算了通式,不过可以出题了qwq

考虑 \(n\) 块积木,给定 \(m\) ,每块积木大小为 \(1 \times k,k \in \left[ 1,\left\lceil \dfrac{m}{2} \right\rceil \right]\) ,求能摆成正方形的边长最大值。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; bool solve() {
ll n;
cin >> n;
if (n == 2) return false;
ll a = (n + 1) / 2;
ll ans = a + (n - a) / 3;
cout << ans << '\n';
return true;
} int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}

C

题解

知识点:构造。

\(n \leq 3\) 或 \(n = 7\) 时无解。

考虑 \(n\bmod 4 = 0,1,2,3\) 的情况。

  1. \(n \bmod 4 = 0\) 时显然形如构造 \(3,4,1,2\) 的循环即可。
  2. \(n \bmod 4 = 1\) 时,前 \(5\) 项构造成 \(4,5,1,2,3\) ,其余仿照 \(n \bmod 4 = 0\) 情况。
  3. \(n \bmod 4 = 2\) 时,前 \(6\) 项构造成 \(4,5,6,1,2,3\) ,其余仿照 \(n \bmod 4 = 0\) 情况。
  4. \(n \bmod 4 = 3\) 时,前 \(11\) 项构造分为 \(5\) 项和 \(6\) 项两组仿照 \(n \bmod 4 = 1,2\) 情况,其余仿照 \(n \bmod 4 = 0\) 情况。

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; bool solve() {
int n;
cin >> n;
if (n <= 3 || n == 7) return false;
int m = 1;
if (n % 4 == 1) {
cout << "4 5 1 2 3" << ' ';
m = 6;
}
else if (n % 4 == 2) {
cout << "4 5 6 1 2 3" << ' ';
m = 7;
}
else if (n % 4 == 3) {
cout << "4 5 1 2 3 9 10 11 6 7 8" << ' ';
m = 12;
}
for (int i = m;i <= n;i += 4) {
cout << i + 2 << ' ' << i + 3 << ' ' << i << ' ' << i + 1 << ' ';
}
cout << '\n';
return true;
} int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
//cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}

D

题解

知识点:博弈论。

这类题需要先对局面分类,每种局面考虑找到一组平衡的操作,即对于其中一人,无论另一人如何操作,他都可以在下一次操作后回到原来的局面。

考虑将 \(n\) 分奇偶情况:

  1. \(n\) 为偶数,小红每次可以选 \(1\) ,随后数变为奇数局面,小紫只有奇数因子能选,数又变为偶数局面。到最后,必然是小紫让数变为 \(0\) ,因为只有小紫能让数变为偶数。因此,偶数局面小红必胜。
  2. \(n\) 为奇数,根据 \(n\) 为偶数的推理,发现奇数局面小红必败。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll n;
cin >> n;
if (n & 1) cout << "yukari" << '\n';
else cout << "kou" << '\n';
return 0;
}

E

题解

知识点:计算几何。

设 \(A(x_A,y_A),B(x_B,y_B),C(x_C,y_C)\) 构成等腰直角三角形,其中 \(C\) 为顶点且在 \(AB\) 右侧,满足方程:

\[\left\{
\begin{aligned}
x_C+y_C = x_A + y_B\\
x_C-y_C = x_B - y_A
\end{aligned}
\right.
\]

方程可以通过全等三角形证明。

显然 \(C\) 和 \(C\) 关于 \(AB\) 的对称点同时是或不是整数点,解出 \(C(x_C,y_C)\) 后判断是否为整数即可。

(平面几何永远的痛,并且以为无解输出-1收获WA

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll x = a + d + c - b;
ll y = a + d + b - c;
if (x & 1 || y & 1)cout << "No Answer!" << '\n';
else cout << x / 2 << ' ' << y / 2 << '\n'; return 0;
}

F

题解

知识点:宇宙的终极答案。

通过你高超的中文流读取技术,发现这是营销号特有的文案。

本打算对此嗤之以鼻的你,阅读完样例后逐渐理解了一切,确信 \(42\) 就是宇宙的终极答案。

时间复杂度 \(O(\infin)\)

空间复杂度 \(O(\infin)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << 42 << '\n';
return 0;
}

G

题解

知识点:模拟,枚举,dfs。

很简单(痛苦)的模拟。

dfs枚举每个 ? 的三种可能即可,注意快速幂前把底数模一下,因为可能炸 long long

可以选择预处理数字后边枚举边求值,也可以考虑枚举完再求值。注意,边枚举边求值不太适用于有优先级表达式。

(被表达式求值整了一顿,码力太差了QAQ

时间复杂度 \(O(3^{12} \cdot n)\)

空间复杂度 \(O(n)\)

代码

边枚举边求值

#include <bits/stdc++.h>
using namespace std;
using ll = long long; ll qpow(ll a, ll k, ll P) {
ll ans = 1;
while (k) {
if (k & 1) ans = ans * a % P;
k >>= 1;
a = a * a % P;
}
return ans;
} int ans;
vector<int> num;
vector<char> op(20);
bool dfs(int step = 1, ll cur = num[0]) {
if (step == num.size()) return cur == ans;
op[step] = '+';
if (dfs(step + 1, cur + num[step])) return true;
op[step] = '-';
if (dfs(step + 1, cur - num[step])) return true;
if (cur > 0 && num[step] > 0) {
op[step] = '#';
if (dfs(step + 1, qpow(cur % num[step], cur, num[step]))) return true;
}
return false;
} int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string s;
cin >> s;
for (int i = 0;i < s.size();i++) {
if (isdigit(s[i])) ans = ans * 10 + s[i] - '0';
else num.push_back(ans), ans = 0;
}
if (dfs()) {
cout << num[0];
for (int i = 1;i < num.size();i++) cout << op[i] << num[i];
cout << '=' << ans << '\n';
}
else cout << -1 << '\n';
return 0;
}

枚举完求值,用到表达式计算。

这里给了一个模板,可以修改map的优先级,支持带括号的二元运算,以及伪负号运算(指负号运算必须打括号)。

#include <bits/stdc++.h>
using ll = long long;
using namespace std; ll qpow(ll a, ll k, ll P) {
ll ans = 1;
while (k) {
if (k & 1) ans = ans * a % P;
k >>= 1;
a = a * a % P;
}
return ans;
} map<char, int> mp = { {'+',0},{'-',0},{'#',0},{'=',0} };
bool calc(string s) {
vector<ll> num = { 0 };
vector<char> op;
for (auto ch : s) {
if (ch >= '0' && ch <= '9') num.back() = num.back() * 10 + ch - '0';
else {
while (op.size() && mp[ch] <= mp[op.back()]) {
char ope = op.back();
op.pop_back();
ll x = num.back();
num.pop_back();
if (ope == '+') num.back() += x;
else if (ope == '-') num.back() -= x;
else if (ope == '#') {
if (x <= 0) return false;
num.back() = qpow(num.back() % x, num.back(), x);
}
}
if (ch == '#' && num.back() <= 0) return false;
op.push_back(ch);
num.push_back(0);
}
}
return num[0] == num[1];
} string s;
bool dfs(int step = 0) {
if (step == s.size()) return calc(s);
if (s[step] == '?') {
s[step] = '+';
if (dfs(step + 1)) return true;
s[step] = '-';
if (dfs(step + 1)) return true;
s[step] = '#';
if (dfs(step + 1)) return true;
s[step] = '?';
}
else {
while (step < s.size() && s[step] != '?') step++;
if (dfs(step)) return true;
}
return false;
} int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
if (dfs()) cout << s << '\n';
else cout << -1 << '\n';
return 0;
}

H

题解

知识点:概率dp。

可能重要的前置知识(大佬请跳过):

对于一维期望dp,在第 \(i\) 步时,其向其他状态转移的起点只有 \(f_i\) 一种,因此在第 \(i\) 步起点是状态 \(f_i\) 的概率是百分百的,变化的期望直接加就行。

例如,有期望状态 \(f_i\) 。操作有两种,概率分别为 \(\dfrac{1}{4},\dfrac{3}{4}\),两种操作的贡献分别是 \(1,3\) 。那么可以有转移方程:

\[f_{i+1} = \dfrac{1}{4}(f_i+1) + \dfrac{3}{4}(f_i+3)
\]

但是,如果在一维期望dp的基础上,设每一步都有多个不同的状态,那么转移时的期望就不是简单加法了。

具体的说,在第 \(i\) 步时,其向其他状态转移的起点如果是 \(f_{i,j}\) 有 \(j\) 种,那么显然这 \(j\) 种状态都有概率成为起点,满足概率的总和为百分百。因此考虑 \(f_{i,j}\) 为起点做转移时,变化的期望需要乘上其作为起点的概率,表示这步操作在 \(f_{i,j}\) 作为起点的概率下的期望。当然,期望 \(f_{i,j}\) 本身不需要再乘一遍概率,因为求这个期望时已经考虑了到这个状态的概率,同时我们还可以知道这 \(j\) 种期望的总和就是第 \(i\) 步的总期望。

例如,有期望状态 \(f_{i,0/1/2}\) ,设 \(f_{i,j}\) 的概率为 \(g_{i,j}\) 。操作有两种,概率分别为 \(\dfrac{1}{4},\dfrac{3}{4}\) ,我们假设从 \(f_{i,0/2}\) 都可以通过两种操作转移到 \(f_{i+1,0}\) ,两种操作的贡献对于两种状态分别是 \(1,2\) 和 \(5,6\) 。那么对于 \(f_{i+1,0}\) 可以有转移方程:

\[\begin{aligned}
f_{i+1,0} &= \dfrac{1}{4}(f_{i,0} + 1\cdot g_{i,0}) + \dfrac{3}{4}(f_{i,0} + 2 \cdot g_{i,0})\\
&+\dfrac{1}{4}(f_{i,2} + 5\cdot g_{i,2})+\dfrac{3}{4}(f_{i,2} + 6 \cdot g_{i,2})
\end{aligned}
\]

接下来就可以轻松(真的吗)做这道题了。

设 \(f_{i,j,k}\) 为执行到第 \(i\) 步且满足串首状态为 \(j\) 、串尾状态为 \(k\) 的期望个数。其中,\(j = 0/1\) 表示串首是 rededr , \(k = 0/1\) 同理。

设 \(g_{i,j,k}\) 为对应的 \(f_{i,j,k}\) 发生的概率。注意,除了四种串首尾的状态,还有一种空串的状态,这里没有标记到数组里,但是每步还是得自己手动加上去的,我们记 \(prob\) 为空串的概率,空串的期望为 \(0\) 不需要考虑。

因此有转移方程:

\[\left\{
\begin{aligned}
f_{i+1,0,0} &= \frac{1}{3} \cdot ((0 + 1 \cdot prob) + (f_{i,0,0} + 1 \cdot g_{i,0,0})+(f_{i,0,1}+1\cdot g_{i,0,1}))\\
&+ \frac{1}{3} \cdot 0\\
&+ \frac{1}{3} \cdot (10 \cdot f_{i,0,0})\\

f_{i+1,0,1} &= \frac{1}{3} \cdot 0\\
&+ \frac{1}{3} \cdot ((f_{i,0,0} + 0 \cdot g_{i,0,0})+(f_{i,0,1}+1 \cdot g_{i,0,1}))\\
&+ \frac{1}{3} \cdot (10\cdot f_{i,0,1})\\

f_{i+1,1,0} &=\frac{1}{3} \cdot ((f_{i,1,0} + 1 \cdot g_{i,1,0})+(f_{i,1,1}+1 \cdot g_{i,1,1}))\\
&+\frac{1}{3} \cdot 0\\
&+\frac{1}{3} \cdot (10 \cdot f_{i,1,0})\\

f_{i+1,1,1} &= \frac{1}{3} \cdot 0\\
&+ \frac{1}{3} \cdot ((0 + 0 \cdot prob) + (f_{i,1,0} + 0 \cdot g_{i,1,0})+(f_{i,1,1}+1 \cdot g_{i,1,1}))\\
&+ \frac{1}{3} \cdot (10 \cdot f_{i,1,1} + 9 \cdot g_{i,1,1})\\

g_{i+1,0,0} &= \frac{1}{3} \cdot (prob + g_{i,0,0} + g_{i,0,1}) + \frac{1}{3} \cdot 0 + \frac{1}{3} \cdot g_{i,0,0}\\\

g_{i+1,0,1} &= \frac{1}{3} \cdot 0 + \frac{1}{3} \cdot (g_{i,0,0} + g_{i,0,1}) + \frac{1}{3} \cdot g_{i,0,1}\\\

g_{i+1,1,0} &= \frac{1}{3} \cdot (g_{i,1,0} + g_{i,1,1}) + \frac{1}{3} \cdot 0 + \frac{1}{3} \cdot g_{i,1,0}\\\

g_{i+1,1,1} &= \frac{1}{3} \cdot 0 + \frac{1}{3} \cdot (prob + g_{i,1,0} + g_{i,1,1}) + \frac{1}{3} \cdot g_{i,1,1}\\\
prob' &= \frac{1}{3} \cdot prob
\end{aligned}
\right.
\]

写的很详细了,三个 \(\dfrac{1}{3}\) 对应三种操作,分别算一下概率和期望转移就行。特别注意,\(f_{i+1,1,1}\) 的操作三转移可以产生十倍加九的期望。

代码用滚动数组压缩了一维, \(f_{j,k,0/1}\) 代表第 \(i\) 步的各种概率/期望, \(g_{j,k,0/1}\) 代表第 \(i+1\) 步的各种概率/期望。并且,代码转移时是用子状态刷表,而非如上述转移方程填表,因为写起来比较方便。填表也能写,本质都是一样的,很好理解。

推荐使用 Modint 不然开 long long 也救不了打 % 打到手酸。

时间复杂度 \(O(k)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; const int P = 1e9 + 7;
struct Modint {
int val;
Modint(int _val = 0):val(_val %P) { format(); }
Modint(ll _val):val(_val %P) { format(); } //if val in [-P,2P)
//maybe slower than global version
Modint &format() {
if (val < 0) val += P;
if (val >= P) val -= P;
return *this;
}
Modint inv()const { return qpow(*this, P - 2); } Modint &operator+=(const Modint &x) { val += x.val;return format(); }
Modint &operator-=(const Modint &x) { val -= x.val;return format(); }
Modint &operator*=(const Modint &x) { val = 1LL * val * x.val % P;return *this; }
Modint &operator/=(const Modint &x) { return *this *= x.inv(); }
friend Modint operator-(const Modint &x) { return { -x.val }; }
friend Modint operator+(Modint a, const Modint &b) { return a += b; }
friend Modint operator-(Modint a, const Modint &b) { return a -= b; }
friend Modint operator*(Modint a, const Modint &b) { return a *= b; }
friend Modint operator/(Modint a, const Modint &b) { return a /= b; } friend Modint qpow(Modint a, ll k) {
Modint ans = 1;
while (k) {
if (k & 1) ans = ans * a;
k >>= 1;
a = a * a;
}
return ans;
} friend istream &operator>>(istream &is, Modint &x) {
ll _x;
is >> _x;
x = { _x };
return is;
}
friend ostream &operator<<(ostream &os, const Modint &x) { return os << x.val; }
};
/*
f[0/1][0/1][0]:概率
f[0/1][0/1][1]:期望
00 red-red
01 red-edr
10 edr-red
11 edr-edr
注意还有一种空串情况
需要每次操作前手动加
*/
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int k;
cin >> k;
array<array<array<Modint, 2>, 2>, 2> f = {};
Modint inv3 = Modint(3).inv();
Modint prob = 1;
for (int i = 1;i <= k;i++) {
//prod指空串概率,空串期望始终为0不需要管
array<array<array<Modint, 2>, 2>, 2> g = {};
g[0][0][0] = inv3 * prob;
g[1][1][0] = inv3 * prob;
g[0][0][1] = inv3 * prob;
//空串到g[1][1]的期望还是0,不用管
for (auto i : { 0,1 }) {
for (auto j : { 0,1 }) {
g[i][0][0] += inv3 * f[i][j][0];//操作1后的概率
g[i][1][0] += inv3 * f[i][j][0];//操作2后的概率
g[i][j][0] += inv3 * f[i][j][0];//操作3后的概率 g[i][0][1] += inv3 * f[i][j][1];//操作1后的期望
g[i][0][1] += inv3 * f[i][j][0];
g[i][1][1] += inv3 * f[i][j][1];//操作2后的期望
if (j == 1) g[i][1][1] += inv3 * f[i][j][0];//只有?1才能加
g[i][j][1] += 10 * inv3 * f[i][j][1];//操作3后的期望
if (i == 1 && j == 1) g[i][j][1] += 9 * inv3 * f[i][j][0];//只有11能加9个
}
}
prob *= inv3;
f = g;
}
Modint sum = 0;
for (auto i : { 0,1 })for (auto j : { 0,1 }) sum += f[i][j][1];
cout << sum << '\n';
return 0;
}

I

题解

知识点:数论,构造。

  1. 偶数情况,若 \(x-1\) 是素数构造 \(n = (x-1)^2\) ,则 \(f(n) = 1+x-1=x\) ; 若 \(x-3\) 是素数构造 \(n = 2(x-3)\) ,则 \(f(n) = 1+2+x-3=x\) 。

  2. 奇数情况,因为一定存在 \(1\) 因子,我们考虑使其他因子的和凑出一个偶数 \(x-1\) 。考虑最简单的素数情况,因为哥德巴赫猜想,一个大于等于 \(4\) 的偶数可以被分解成两个素数之和,我们只要找到两个不同的素数 \(p,q\) 使得 \(p+q = x-1\) ,那么构造 \(n = pq\) ,则 \(f(n) = 1+p+q=x\) 。

    注意,哥德巴赫猜想所述是两个素数之和,不是两个不同的素数。经过测试 int 范围内,大于等于 \(8\) 的偶数都可以被分解为两个不同的素数之和,因此大于等于 \(9\) 的奇数我们无脑无解即可。

    我们需要特判 \(x = 1,3,7\) ,因为这些情况确实有解,但不能通过哥德巴赫猜想构造。

时间复杂度 \(O(x)\)

空间复杂度 \(O(x)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long; const int N = 1e6 + 7;
bool vis[N];
vector<int> prime;
void get_prime(int n) {
for (int i = 2;i <= n;i++) {
if (!vis[i]) prime.push_back(i);
for (int j = 0;j < prime.size() && i * prime[j] <= n;j++) {
vis[i * prime[j]] = 1;
if (!(i % prime[j])) break;
}
}
} bool solve() {
int x;
cin >> x;
if (x == 1) {
cout << 2 << '\n';
return true;
}
if (x == 3) {
cout << 4 << '\n';
return true;
}
if (x == 7) {
cout << 8 << '\n';
return true;
}
if (x & 1) {
for (int i = 0;i < prime.size() && 2 * prime[i] < x - 1;i++) {
if (!vis[x - 1 - prime[i]]) {
cout << 1LL * prime[i] * (x - 1 - prime[i]) << '\n';
return true;
}
}
}
else {
if (!vis[x - 1]) cout << 1LL * (x - 1) * (x - 1) << '\n';
else cout << 1LL * 2 * (x - 3) << '\n';
return true;
}
return false;
} int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
get_prime(1e6);
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}

K

题解

知识点:贪心,数学。

给你前 \(n\) 种素数,每个素数有 \(a_i\) 个。

设 \(size = \sum_{i=1}^n a_i\) 。现在将这 \(size\) 个素数排成一个序列,设 \(f(i)\) 为序列中 \([1,i]\) 的数的乘积的因子的数量。现在求 \([1,size]\) 的 \(f(i)\) 的和,即 \(\sum_{i=1}^{size} f(i)\) ,的最大值。

显然,我们需要尽可能让前面的 \(f(i)\) 的越大越好。我们知道,乘积的因子数量等于各个素数个数加 \(1\) 的乘积,通过一些尝试很容易发现均摊素数的个数,比连续安排同一种素数得到的结果要大很多,因此我们每次安排还能安排的素数中出现次数最小的那个素数。

我们设 \(cnt_i\) 表示出现至少 \(i\) 次的素数个数,我们发现 \(f(i)\) 的结果呈现 \(2,2^2,\cdots,2^{cnt_1},2^{cnt_1-1} \cdot 3,\cdots,2^{cnt_1-cnt_2} \cdot 3^{cnt_2},\cdots\) 。直接求和要加 \(size\) 次是不可行的,因此我们先用差分维护好 \(cnt_i\) ,随后用等比公式对每 \(cnt_i\) 个数直接求和。

设 \(pre\) 为 \(cnt_{i-1}\) 段的最后一个数字,那么 \(cnt_i\) 段的总和为 \(pre \cdot \dfrac{1-\frac{i+1}{i}^{cnt_i}}{1-\frac{i+1}{i}}\) ,最后一个数字 \(pre' = pre \cdot \dfrac{i+1}{i}^{cnt_i}\) ,于是就可以递推求和了。

时间复杂度 \(O(2 \cdot 10^5 + n)\)

空间复杂度 \(O(2 \cdot 10^5)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std; const int P = 1e9 + 7;
ll qpow(ll a, ll k) {
ll ans = 1;
while (k) {
if (k & 1) ans = ans * a % P;
k >>= 1;
a = a * a % P;
}
return ans;
} ll inv(ll a) { return qpow(a, P - 2); } int cnt[200007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1;i <= n;i++) {
int x;
cin >> x;
cnt[1]++;
cnt[x + 1]--;
}
for (int i = 1;i <= 2e5;i++) cnt[i] += cnt[i - 1];
int pre = 1;
int ans = 0;
for (int i = 1;i <= 2e5;i++) {
int f = 1LL * (i + 1) * inv(i) % P;
int g = qpow(f, cnt[i]);
ans = (ans + 1LL * pre * f % P * (1 - g + P) % P * inv(1 - f + P) % P) % P;
pre = 1LL * pre * g % P;
}
cout << ans << '\n';
return 0;
}

2023牛客寒假算法基础集训营3 A-I+K的更多相关文章

  1. 2020牛客寒假算法基础集训营2 J题可以回顾回顾

    2020牛客寒假算法基础集训营2 A.做游戏 这是个签到题. #include <cstdio> #include <cstdlib> #include <cstring ...

  2. 2020牛客寒假算法基础集训营1 J题可以回顾回顾

    2020牛客寒假算法基础集训营1 这套题整体来说还是很简单的. A.honoka和格点三角形 这个题目不是很难,不过要考虑周全,面积是1,那么底边的长度可以是1也可以是2, 注意底边1和2会有重复的, ...

  3. Applese 的毒气炸弹 G 牛客寒假算法基础集训营4(图论+最小生成树)

    链接:https://ac.nowcoder.com/acm/contest/330/G来源:牛客网 Applese 的毒气炸弹 时间限制:C/C++ 2秒,其他语言4秒 空间限制:C/C++ 262 ...

  4. 牛客寒假算法基础集训营3B 处女座的比赛资格(用拓扑排序解决DAG中的最短路)

    链接:https://ac.nowcoder.com/acm/contest/329/B 来源:牛客网 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 262144K,其他语言5242 ...

  5. 牛客寒假算法基础集训营4 I题 Applese 的回文串

    链接:https://ac.nowcoder.com/acm/contest/330/I 来源:牛客网 自从 Applese 学会了字符串之后,精通各种字符串算法,比如--判断一个字符串是不是回文串. ...

  6. 牛客寒假算法基础集训营4 I Applese 的回文串

    链接:https://ac.nowcoder.com/acm/contest/330/I来源:牛客网 自从 Applese 学会了字符串之后,精通各种字符串算法,比如……判断一个字符串是不是回文串. ...

  7. 牛客寒假算法基础集训营2 【处女座与复读机】DP最小编辑距离【模板题】

    链接:https://ac.nowcoder.com/acm/contest/327/G来源:牛客网 一天,处女座在牛客算法群里发了一句“我好强啊”,引起无数的复读,可是处女座发现复读之后变成了“处女 ...

  8. 欧拉函数-gcd-快速幂(牛客寒假算法基础集训营1-D-小a与黄金街道)

    题目描述: 链接:https://ac.nowcoder.com/acm/contest/317/D来源:牛客网小a和小b来到了一条布满了黄金的街道上.它们想要带几块黄金回去,然而这里的城管担心他们拿 ...

  9. 牛客寒假算法基础集训营3处女座和小姐姐(三) (数位dp)

    链接:https://ac.nowcoder.com/acm/contest/329/G来源:牛客网 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 262144K,其他语言52428 ...

  10. 牛客寒假算法基础集训营4 F Applese 的大奖

    链接:https://ac.nowcoder.com/acm/contest/330/H来源:牛客网 Applese 和它的小伙伴参加了一个促销的抽奖活动,活动的规则如下:有一个随机数生成器,能等概率 ...

随机推荐

  1. 【UML】统一建模语言

    如果是准备学习设计模式的同学,可以只了解类图相关的知识 而如果是在准备软件设计师考试的同学,或许会对你有点帮助 正在施工...... 参考博客:https://blog.csdn.net/unique ...

  2. 用昇腾AI护航“井下安全”

    摘要:基于CANN(异构计算架构)打造的"智能矿山安全生产管理平台",能够更便捷和更高效地服务于更多矿山安全生产建设. 本文分享自华为云社区<华为携手云话科技助力矿山智能化, ...

  3. SQL--存储过程的使用

    存储过程的概念 存储过程类似一个函数,可以执行一条或者多条SQL语句,可带参数,可返回值 为了简化操作,方便更改和扩展,将一个事件的处理封装在一个单元中供使用. 创建存储过程 --创建存储过程(不带参 ...

  4. 利用xtrabackup8完全,增量备份及还原MySQL8

    利用xtrabackup8完全,增量备份及还原MySQL8 1.环境准备 服务器 作用 数据库版本 xtrabackup版本 10.0.0.8 数据备份 mysql8.0.26 8.0.28 10.0 ...

  5. 三、Ocelot请求聚合与负载均衡

    上一篇文章介绍了在.Net Core中如何使用Ocelot:https://www.cnblogs.com/yangleiyu/p/16847439.html 本文介绍在ocelot的请求聚合与负载均 ...

  6. VirtualBox 下 CentOS7 静态 IP 的配置 → 多次踩坑总结,蚌埠住了!

    开心一刻 一个消化不良的病人向医生抱怨:我近来很不正常,吃什么拉什么,吃黄瓜拉黄瓜,吃西瓜拉西瓜,怎样才能恢复正常呢? 医生沉默片刻:那你只能吃屎了 环境准备 VirtualBox 6.1 网络连接方 ...

  7. 新建Maui工程运行到IiOS物理设备提示 Could not find any available provisioning profiles for iOS 处理办法

    在构建 MAUI App 或 MAUI Blazor 时,您可能会收到以下 Could not find any available provisioning profiles for iOS. Pl ...

  8. redis的缓存穿透、击穿、雪崩以及实用解决方案

    今天来聊聊redis的缓存穿透.击穿.雪崩以及解决方案,其中解决方案包括类似于布隆过滤器这种网上一搜一大片但是实际生产部署有一定复杂度的,也有基于spring注解通过一行代码就能解决的,其中各有优劣, ...

  9. C#怎么在生成解决方案的过程中执行perl脚本(C#早期绑定)

    转载 怎么在生成解决方案的过程中执行perl脚本 早期绑定在编译期间识别并检查方法.属性.函数,并在应用程序执行之前执行其他优化.在这个绑定中,编译器已经知道它是什么类型的对象以及它拥有的方法或属性. ...

  10. elasticsearch多字段聚合实现方式

    目录 1.背景 2.实现多字段聚合的思路 3.需求 4.数据准备 4.1 创建索引 4.2 准备数据 5.实现方式 5.1 multi_terms实现 5.1.1 dsl 5.1.2 java 代码 ...