ABC 478 题解
A - Grapes
翻译
得分: $100$ 分问题陈述
有 \(N\) 人,编号从 \(1\) 到 \(N\) 。
有 \(M\) 粒葡萄。它们将按以下方式分配给 \(N\) 人。
- 按以下顺序给 \(1,2,\dots,N\) 人每人一颗葡萄。如果中途葡萄吃完了,分配就到此为止。
- 如果分给 \(N\) 人后还有剩余,就回到 \(1\) 人那里,再次按顺序分发。如此重复,直到葡萄分完。
计算每个人分到了多少颗葡萄。
约束条件
- \(1 \leq N \leq 100\)
- \(1 \leq M \leq 10000\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(M\)
输出
输出 \(N\) 行。 \(i\) -th 行应包含 \(i\) 收到的葡萄数量。
输入示例 1
3 5
样本输出 1
2
2
1
五颗葡萄依次分给 \(1,2,3,1,2\) 人。
输入示例 2
4 1
样本输出 2
1
0
0
0
可能有人没有收到葡萄。
输入样本 3
12 3456
输出样本 3
288
288
288
288
288
288
288
288
288
288
288
288
每个人都可以得到相同数量的葡萄。
题意
有 \(N\) 个人,按 \(1,2,\dots,N\) 的顺序循环发葡萄,一共发 \(M\) 颗。问最后每个人拿到几颗。
思路
这题没什么花哨的,直接模拟就行。
用一个变量 tot 表示当前该谁拿,初始是 1。每发一颗葡萄,就让 tot 加 1,超过 \(N\) 就绕回 1。发完 \(M\) 颗之后,ans[i] 就是第 \(i\) 个人拿到的数量。
代码
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 1e2 + 10;
int n;
int m;
int tot = 1;
int ans[MAXN];
signed main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n >> m;
while (m--)
{
ans[tot]++;
tot++;
if (tot > n)
{
tot = 1;
}
}
for (int i = 1; i <= n; i++)
{
cout << ans[i] << "\n";
}
return 0;
}
B - Topping
翻译
得分: $200$ 分问题陈述
得分: \(200\) 分
问题陈述
高桥在一家拉面店。
这家店有 \(N\) 种浇头,其中 \(i\) 种浇头的价格为 \(i\) ,幸福感为 \(W_i\) 。
高桥选择了三种不同的配料,这样总价格最多为 \(V\) 。求他所选配料的最大幸福度。
约束条件保证至少有一种方法可以选择三种不同的配料,使总价最多为 \(V\) 。
约束条件
- \(3 \leq N \leq 100\)
- \(6 \leq V \leq 3N-3\)
- \(1 \leq W_i \leq 10^6\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(V\)
\(W_1\),\(W_2\),\(\dots\),\(W_N\)
输出
单行输出答案
输入示例 1
5 9
31 41 59 26 53
样本输出 1
143
选择第一、第三和第五种配料时,总价格为 \(1+3+5=9\) ,总幸福感为 \(31+59+53=143\) 。
输入示例 2
10 16
102228 448944 131224 326172 500169 670309 976672 579051 974511 773940
样本输出 2
2095925
选择第二、第六和第七种配料时,总价格为 \(2+6+7=15\) ,总幸福感为 \(448944+670309+976672=2095925\) 。
题意
拉面店有 \(N\) 种浇头,第 \(i\) 种浇头价格为 \(i\),幸福值为 \(W_i\)。
高桥要选三种不同的浇头,总价格不超过 \(V\)。求最大幸福值。
数据保证至少存在一种合法选择。
思路
\(N \le 100\),直接三重循环枚举三种浇头 \(i < j < k\)。
- 价格就是编号本身,总和是 \(i + j + k\)
- 如果 \(i + j + k \le V\),就把 \(W_i + W_j + W_k\) 拿去更新答案
因为价格只跟编号有关,跟 \(W\) 无关,所以直接按编号枚举就行,不需要额外排序或 DP。
AC 代码
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 1e2 + 10;
int n;
int v;
int w[MAXN];
int ans;
signed main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n >> v;
for (int i = 1; i <= n; i++)
{
cin >> w[i];
}
for (int i = 1; i <= n; i++)
{
for (int j = i + 1; j <= n; j++)
{
for (int k = j + 1; k <= n; k++)
{
if (i + j + k <= v)
{
int sum = w[i] + w[j] + w[k];
ans = max (ans, sum);
}
}
}
}
cout << ans << "\n";
return 0;
}
C - Sort Subarray
翻译
得分: $300$ 分问题陈述
给你一个长度为 \(N\) 的整数序列 \(A=(A_1,A_2,\ldots,A_N)\) 。
你将对 \(A\) 执行以下操作只进行一次。
- 在 \(1\) 和 \(N-K+1\) (含)之间选择一个整数 \(i\) 。将 \(A_i,A_{i+1},\ldots,A_{i+K-1}\) 按升序排序。更正式地说,让 \(B_1,B_2,\ldots,B_K\) 成为按升序排列的 \(A_i,A_{i+1},\ldots,A_{i+K-1}\) ,同时用 \(B_j\) 替换 \(1\le j\le K\) 中的 \(A_{i+j-1}\) 。
请判断经过这样的操作后, \(A\) 是否可能是升序排列,即 \(A_i\le A_{i+1}\) 对所有的 \(1\le i\lt N\) 都成立。
约束条件
- \(1\le K\lt N\le2\times10 ^ 5\)
- \(1\le A_i\le N\\ (1\le i\le N)\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(K\)
\(A_1\),\(A_2\),\(\ldots\),\(A_N\)
输出
如果 \(A\) 可以通过执行一次操作以升序排序,则输出 Yes ;否则,输出 No 。
输入示例 1
9 6
1 4 1 4 2 1 3 5 6
样本输出 1
Yes
例如,如果选择 \(2\) 为 \(i\) ,那么 \((A_2,A_3,A_4,A_5,A_6,A_7)=(4,1,4,2,1,3)\) 将被替换为 \((1,1,2,3,4,4)\) 。操作后, \(A\) 为 \((1,1,1,2,3,4,4,5,6)\) ,满足条件。
因此,输出 Yes 。
输入样本 2
3 1
3 2 1
样本输出 2
No
\(K=1\) ,因此无论对哪个 \(i\) 执行操作, \(A\) 都不会发生变化。因此,输出 No 。
输入示例 3
30 25
1 2 2 22 14 10 14 10 18 5 15 8 17 22 10 17 11 25 13 16 9 19 26 7 11 12 23 3 30 30
输出样本 3
Yes
题意
给一个长度为 \(N\) 的序列 \(A\),你只能做一次操作:
- 选一个起点 \(i\)(\(1 \le i \le N-K+1\))
- 把 \(A_i, A_{i+1}, \dots, A_{i+K-1}\) 这一段升序排序
问操作后整个序列能否变成非递减的。
思路
设我们选的窗口是 \([i, i+K-1]\),排序后这一段的元素就是原来这段的最小值到最大值依次排列。
整个序列要非递减,需要满足四件事:
① 窗口左边 \([1, i-1]\) 已经非递减
用前缀标记 pre[x]:前 \(x\) 个元素是否已经非递减。
② 窗口右边 \([i+K, N]\) 已经非递减
用后缀标记 suf[x]:从第 \(x\) 个到末尾是否已经非递减。
③ 左边最后一个数 \(\le\) 窗口内的最小值
即 \(A_{i-1} \le \min(A_i, \dots, A_{i+K-1})\)。
否则左边会把「大数」接在窗口「小数」的前面,违反非递减。
④ 窗口内的最大值 \(\le\) 右边第一个数
即 \(\max(A_i, \dots, A_{i+K-1}) \le A_{i+K}\)。
否则窗口最后的「大数」接在右边「小数」的前面,同样违反。
关键在于: 窗口内部排序后一定有序,所以只要保证接口处合法就行。
如何快速求窗口最值
用单调队列,在 \(O(N)\) 内预处理出每个长度为 \(K\) 的窗口的最小值和最大值。
- 求最小值:队列维护递增,队首即最小
- 求最大值:队列维护递减,队首即最大
判断流程
对每个 \(i \in [1, N-K+1]\):
- 如果 \(i > 1\),检查
pre[i-1]是否为true,并且 \(A_{i-1} \le mn[i]\) - 如果 \(i+K \le N\),检查
suf[i+K]是否为true,并且 \(mx[i] \le A_{i+K}\) - 两个条件都满足 → 输出
Yes - 全部试完都不行 → 输出
No
AC 代码
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 2e5 + 10;
int n;
int k;
int a[MAXN];
int mn[MAXN];
int mx[MAXN];
int dq[MAXN];
bool pre[MAXN];
bool suf[MAXN];
signed main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n >> k;
for (int i = 1; i <= n; i++)
{
cin >> a[i];
}
pre[0] = true;
for (int i = 1; i <= n; i++)
{
if (i == 1)
{
pre[i] = true;
}
else
{
pre[i] = pre[i - 1] && (a[i - 1] <= a[i]);
}
}
suf[n + 1] = true;
for (int i = n; i >= 1; i--)
{
if (i == n)
{
suf[i] = true;
}
else
{
suf[i] = suf[i + 1] && (a[i] <= a[i + 1]);
}
}
int hd = 1;
int tl = 0;
for (int i = 1; i <= n; i++)
{
while (hd <= tl && a[dq[tl]] >= a[i])
{
tl--;
}
tl++;
dq[tl] = i;
while (hd <= tl && dq[hd] <= i - k)
{
hd++;
}
if (i >= k)
{
mn[i - k + 1] = a[dq[hd]];
}
}
hd = 1;
tl = 0;
for (int i = 1; i <= n; i++)
{
while (hd <= tl && a[dq[tl]] <= a[i])
{
tl--;
}
tl++;
dq[tl] = i;
while (hd <= tl && dq[hd] <= i - k)
{
hd++;
}
if (i >= k)
{
mx[i - k + 1] = a[dq[hd]];
}
}
for (int i = 1; i <= n - k + 1; i++)
{
bool ok = true;
if (i > 1)
{
if (!pre[i - 1])
{
ok = false;
}
if (a[i - 1] > mn[i])
{
ok = false;
}
}
if (i + k <= n)
{
if (!suf[i + k])
{
ok = false;
}
if (mx[i] > a[i + k])
{
ok = false;
}
}
if (ok)
{
cout << "Yes" << "\n";
return 0;
}
}
cout << "No" << "\n";
return 0;
}
D - Range Set Insertion Query
翻译
得分: $400$ 分问题陈述
有 \(N\) 个集合 \(S_1,S_2,\ldots,S_N\) 。最初, \(S_1,S_2,\ldots,S_N\) 都是空集。
下面的运算在这些集合上进行了 \(Q\) 次。在 \(i\) 次运算 \((1\le i\le Q)\) 中,给出了整数 \((L_i,R_i,X_i)\) 的三倍,并执行了下面的运算。
- 把 \(X_i\) 加到 \(S_{L_i},S_{L_i+1},\ldots,S_{R_i}\) 中。
对于每一个 \(i=1,2,\ldots,N\) ,求所有运算结束后 \(S_i\) 的元素个数。
约束条件
- \(1\le N\le2\times10 ^ 5\)
- \(1\le Q\le2\times10 ^ 5\)
- \(1\le L_i\le R_i\le N\\ (1\le i\le Q)\)
- \(1\le X_i\le Q\\ (1\le i\le Q)\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(Q\)
\(L_1\),\(R_1\),\(X_1\)
\(L_2\),\(R_2\),\(X_2\)
\(\vdots\)
\(L_Q\),\(R_Q\),\(X_Q\)
输出
在完成所有 \(Q\) 操作后,依次输出 \(S_1\) \(,\) 的元素个数 \(S_2\) \(,\ldots,\) 的元素个数 \(S_N\) 的元素个数,以空格分隔。
输入示例 1
8 5
2 5 1
1 4 2
7 8 1
3 6 3
2 5 2
样本输出 1
1 2 3 3 3 1 1 1
经过五次运算后,集合分别为 \(\lbrace2\rbrace,\lbrace1,2\rbrace,\lbrace1,2,3\rbrace,\lbrace1,2,3\rbrace,\lbrace1,2,3\rbrace,\lbrace3\rbrace,\lbrace1\rbrace,\lbrace1\rbrace\) 。因此,依次输出它们的元素个数 \(1,2,3,3,3,1,1,1\) ,中间用空格隔开。
输入示例 2
30 20
3 22 11
8 30 10
12 14 7
2 17 4
1 19 12
7 30 15
11 23 2
14 25 17
9 12 7
10 16 7
16 18 19
1 11 14
11 15 4
1 21 6
4 8 10
23 24 11
8 27 10
1 19 12
23 23 16
13 24 12
样本输出 2
3 4 5 6 6 6 7 7 8 8 9 8 8 9 9 10 9 8 7 7 7 6 7 5 3 2 2 2 2 2
题意
有 \(N\) 个集合,初始都是空的。做 \(Q\) 次操作,第 \(i\) 次操作把数字 \(X_i\) 加进 \(S_{L_i}, S_{L_i+1}, \dots, S_{R_i}\)。
问所有操作结束后,每个集合里有多少个元素(重复加入只算一次)。
思路
关键观察
这题不能直接对每次操作做区间 +1 差分,因为同一个数字在同一个集合里只算一次。
举个例子:
- 操作 1:把 1 加入 \([1, 5]\)
- 操作 2:把 1 加入 \([3, 8]\)
如果直接差分加两次,集合 3~5 会被算 2 个元素,但实际上只加了数字 1,只有一个元素。
正确做法:按数字分组 + 区间合并
第一步:按数字 \(X\) 分组。
同一个 \(X\) 的所有区间放在一起,比如:
X = 1: [1,5], [3,8]
X = 2: [2,4], [7,9]
X = 3: [6,6]
第二步:对每个 \(X\) 的区间排序并合并。
同一数字的多个区间如果有重叠或相邻,合并成一个大块。因为在这些位置,这个数字只贡献 1 个元素。
X = 1: [1,5] 和 [3,8] 重叠 → 合并为 [1,8]
X = 2: [2,4] 和 [7,9] 不相交 → 保留两块 [2,4], [7,9]
X = 3: [6,6] → 保留 [6,6]
第三步:对合并后的每个块做差分 +1。
因为合并后,同一个数字在不同块之间不会重叠,每个位置对这个数字最多贡献 1。
X = 1: [1,8] → d[1] += 1, d[9] -= 1
X = 2: [2,4] → d[2] += 1, d[5] -= 1
[7,9] → d[7] += 1, d[10] -= 1
X = 3: [6,6] → d[6] += 1, d[7] -= 1
第四步:前缀和还原答案。
AC 代码
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 2e5 + 10;
int n;
int q;
int l;
int r;
int x;
int cl;
int cr;
int ans;
int d[MAXN];
vector <pair <int, int> > ve[MAXN];
signed main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n >> q;
for (int i = 1; i <= q; i++)
{
cin >> l >> r >> x;
ve[x].push_back ({l, r});
}
for (int x = 1; x <= q; x++)
{
if (ve[x].empty ())
{
continue;
}
sort (ve[x].begin (), ve[x].end ());
//
// cout << "--------------------处理 x = " << x << "--------------------" << "\n";
//
cl = ve[x][0].first;
cr = ve[x][0].second;
for (int j = 1; j < ve[x].size (); j++)
{
l = ve[x][j].first;
r = ve[x][j].second;
//
// cout << "当前区间 [" << l << ", " << r << "] 当前合并块 [" << cl << ", " << cr << "]\n";
//
if (l <= cr + 1)
{
if (r > cr)
{
cr = r;
}
//
// cout << "合并后块变为 [" << cl << ", " << cr << "]\n";
}
else
{
// cout << "区间不连续,结算块 [" << cl << ", " << cr << "]\n";
//
d[cl] += 1;
d[cr + 1] -= 1;
cl = l;
cr = r;
}
}
//
// cout << "结算最后一块 [" << cl << ", " << cr << "]\n";
//
d[cl] += 1;
d[cr + 1] -= 1;
}
//
// cout << "--------------------差分数组--------------------" << "\n";
//
// for (int i = 1; i <= n + 1; i++)
// {
// cout << "d[" << i << "] = " << d[i] << "\n";
// }
//
// cout << "--------------------差分数组结束--------------------" << "\n";
//
for (int i = 1; i <= n; i++)
{
ans += d[i];
cout << ans << " ";
}
cout << "\n";
return 0;
}
E - lt and le
翻译
得分: $475$ 分问题陈述
判断是否存在长度为 \(N\) 的整数序列 \(A\) ,该序列由 \(1\) 和 \(N\) 之间的整数组成,且满足下列所有 \(Q\) 条件,如果存在,请找出一个。
\(i\) -th 条件 \((1\le i\le Q)\) 由整数 \((t_i,u_i,v_i)\) 的三倍给出,其定义如下。
- 如果 \(t_i=0\) : \(A_{u_i}\le A_{v_i}\)
- 如果 \(t_i=1\) : \(A_{u_i}\lt A_{v_i}\)
如果有多个序列满足所有条件,则可以输出其中任意一个。
约束条件
- \(1\le N\le2\times10 ^ 5\)
- \(1\le Q\le2\times10 ^ 5\)
- \(t_i\in\lbrace0,1\rbrace\\ (1\le i\le Q)\)
- \(1\le u_i\le N\\ (1\le i\le Q)\)
- \(1\le v_i\le N\\ (1\le i\le Q)\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(Q\)
\(t_1\),\(u_1\),\(v_1\)
\(t_2\),\(u_2\),\(v_2\)
\(\vdots\)
\(t_Q\),\(u_Q\),\(v_Q\)
输出
如果存在满足条件的整数序列,则在第一行输出 Yes ,否则输出 No 。如果在第一行输出 Yes ,则选择一个满足条件的整数序列,并在第二行输出其元素,用空格分隔。如果有多个序列满足所有条件,则可以任选一个。
输入示例 1
7 8
0 1 4
0 2 6
0 3 2
1 3 5
0 4 1
0 4 3
1 5 7
0 6 7
样本输出 1
Yes
1 4 2 1 3 5 6
设 \(A=(1,4,2,1,3,5,6)\) ;这是一个长度为 \(7\) 的整数序列,由 \(1\) 至 \(7\) 之间的整数(包括首尾两个整数)组成。例如,这里的第一个条件 \(A_1\le A_4\) 自 \(1\le 1\) 起成立。其他七个条件也成立,因此对应于 \(A=(1,4,2,1,3,5,6)\) 的输出被认为是正确的。
此外, \(A=(1,1,1,1,2,2,3)\) 、 \(A=(3,5,4,3,6,7,7)\) 等也满足条件,因此输出这些也被认为是正确的。
输入示例 2
1 1
1 1 1
样本输出 2
No
没有整数序列 \(A\) 令 \(A_1\lt A_1\) 成立。
输入样本 3
15 20
0 9 8
1 6 1
0 6 8
0 11 1
0 4 2
1 11 12
0 4 14
1 10 1
0 12 12
1 7 12
1 13 1
1 5 9
1 10 14
1 14 1
1 8 12
0 10 12
1 4 15
1 3 9
0 5 14
0 10 2
输出样本 3
Yes
15 14 10 7 6 5 4 12 11 3 2 13 1 9 8
题意
给 \(N\) 个变量 \(A_1, \dots, A_N\),每个取值在 \([1, N]\)。给 \(Q\) 条约束:
- \(t_i = 0\):\(A_{u_i} \le A_{v_i}\)
- \(t_i = 1\):\(A_{u_i} < A_{v_i}\)
判断是否有解,有解则输出一组方案。
思路
核心建模
所有约束都是不等式,看成有向边:
- \(t = 0\):\(u \to v\),边权 0,表示「\(v\) 不比 \(u\) 小」
- \(t = 1\):\(u \to v\),边权 1,表示「\(v\) 严格比 \(u\) 大」
第一步:SCC 缩点
如果 \(u\)、\(v\) 互相可达,那么 \(A_u = A_v\),缩成同一个 SCC。
矛盾检测:
- \(u = v\) 且 \(t = 1\) → 无解
- 同一 SCC 内存在一条 \(t = 1\) 的边 → 无解
第二步:DAG 最长路
缩点后得到 DAG。设 \(dp[\text{scc}]\) 表示到当前 SCC 的最长路径边权和。
拓扑排序递推:
\(dp[v] = \max(dp[v],dp[u] + w) \)
第三步:赋值
令 \(A_i = dp[\text{scc}(i)] + 1\)。
- 边权 0:\(dp[v] \ge dp[u]\),所以 \(A_v \ge A_u\)
- 边权 1:\(dp[v] \ge dp[u] + 1\),所以 \(A_v > A_u\)
第四步:检查上界
若最长路长度 \(+ 1 > N\),则无解。否则所有 \(A_i \in [1, N]\)。
复杂度
| 步骤 | 复杂度 |
|---|---|
| Tarjan 求 SCC | \(O(N + Q)\) |
| 缩点建 DAG | \(O(Q)\) |
| 排序去重 | \(O(Q \log Q)\) |
| 拓扑排序 + 最长路 | \(O(N + Q)\) |
| 总计 | \(O(N + Q \log Q)\) |
AC 代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 10;
int n;
int q;
int ec;
int rc;
int dc;
int uc;
int sc;
int id;
int tp;
int hd;
int tl;
int mxv;
int u[MAXN];
int v[MAXN];
int t[MAXN];
int he[MAXN];
int re[MAXN];
int dg[MAXN];
int qu[MAXN];
int st[MAXN];
int vl[MAXN];
int hn[MAXN * 2];
int ht[MAXN * 2];
int hw[MAXN * 2];
int rn[MAXN * 2];
int rt[MAXN * 2];
int rw[MAXN * 2];
int dfn[MAXN];
int low[MAXN];
int scc[MAXN];
int deu[MAXN];
int dev[MAXN];
int dew[MAXN];
int ueu[MAXN];
int uev[MAXN];
int uew[MAXN];
int dgh[MAXN];
int dgn[MAXN * 2];
int dgt[MAXN * 2];
int dgw[MAXN * 2];
bool vs[MAXN];
struct Ed
{
int u;
int v;
int w;
} ;
Ed de[MAXN];
bool cmp (const Ed& a, const Ed& b)
{
if (a.u != b.u)
{
return a.u < b.u;
}
return a.v < b.v;
}
void add (int* h, int* hn, int* ht, int* hw, int u, int v, int w, int& cnt)
{
cnt++;
ht[cnt] = v;
hw[cnt] = w;
hn[cnt] = h[u];
h[u] = cnt;
}
void tarjan (int u)
{
id++;
dfn[u] = id;
low[u] = id;
tp++;
st[tp] = u;
vs[u] = true;
for (int e = he[u]; e; e = hn[e])
{
int v = ht[e];
if (!dfn[v])
{
tarjan (v);
low[u] = min (low[u], low[v]);
}
else if (vs[v])
{
low[u] = min (low[u], dfn[v]);
}
}
if (low[u] == dfn[u])
{
sc++;
while (true)
{
int x = st[tp];
tp--;
vs[x] = false;
scc[x] = sc;
if (x == u)
{
break;
}
}
}
}
int main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n >> q;
for (int i = 1; i <= q; i++)
{
cin >> t[i] >> u[i] >> v[i];
if (t[i] == 1 && u[i] == v[i])
{
cout << "No\n";
return 0;
}
add (he, hn, ht, hw, u[i], v[i], t[i], ec);
add (re, rn, rt, rw, v[i], u[i], t[i], rc);
}
for (int i = 1; i <= n; i++)
{
if (!dfn[i])
{
tarjan (i);
}
}
for (int i = 1; i <= q; i++)
{
if (scc[u[i]] == scc[v[i]] && t[i] == 1)
{
cout << "No\n";
return 0;
}
}
dc = 0;
for (int i = 1; i <= q; i++)
{
if (scc[u[i]] != scc[v[i]])
{
dc++;
de[dc].u = scc[u[i]];
de[dc].v = scc[v[i]];
de[dc].w = t[i];
}
}
sort (de + 1, de + dc + 1, cmp);
uc = 0;
for (int i = 1; i <= dc; )
{
int su = de[i].u;
int sv = de[i].v;
int mw = 0;
int j = i;
while (j <= dc && de[j].u == su && de[j].v == sv)
{
mw = max (mw, de[j].w);
j++;
}
uc++;
ueu[uc] = su;
uev[uc] = sv;
uew[uc] = mw;
i = j;
}
for (int i = 1; i <= uc; i++)
{
add (dgh, dgn, dgt, dgw, ueu[i], uev[i], uew[i], rc);
dg[uev[i]]++;
}
for (int i = 1; i <= sc; i++)
{
vl[i] = 1;
}
hd = 1;
tl = 0;
for (int i = 1; i <= sc; i++)
{
if (dg[i] == 0)
{
tl++;
qu[tl] = i;
}
}
while (hd <= tl)
{
int x = qu[hd];
hd++;
for (int e = dgh[x]; e; e = dgn[e])
{
int y = dgt[e];
vl[y] = max (vl[y], vl[x] + dgw[e]);
dg[y]--;
if (dg[y] == 0)
{
tl++;
qu[tl] = y;
}
}
}
mxv = 0;
for (int i = 1; i <= sc; i++)
{
mxv = max (mxv, vl[i]);
}
if (mxv > n)
{
cout << "No\n";
return 0;
}
cout << "Yes\n";
for (int i = 1; i <= n; i++)
{
cout << vl[scc[i]] << " ";
}
cout << "\n";
return 0;
}
F - Min-First Search
翻译
得分: $525$ 分问题陈述
对于一棵树 \(T\) 有 \(N\) 个顶点,分别称为顶点 \(1\) 、顶点 \(2\) 、 \(\ldots\) 、顶点 \(N\) ,设 \(f(T)\) 是 \((1,2,\ldots,N)\) 的置换 \(P\) ,由以下步骤得到。
- 最初,设序列 \(P\) 为空序列 \(()\) ,设集合 \(S\) 为 \(\lbrace1\rbrace\) 。
- 重复下面的 \(N\) 次。
- 设 \(x\) 是 \(S\) 的最小值。从 \(S\) 中删除 \(x\) ,并将 \(x\) 追加到 \(P\) 的末尾。
- 那么,让 \(v_1, v_2, \ldots, v_k\) 成为 \(T\) 中与顶点 \(x\) 相邻的顶点。对于 \(i=1,2,\ldots,k\) ,如果 \(v _ i\) 不包含在 \(P\) 中,则将 \(v _ i\) 添加到 \(S\) 中。
给你一个 \((1,2,\ldots,N)\) 的排列组合 \(Q=(Q _ 1,Q _ 2,\ldots,Q _ N)\) 。求在 \(998244353\) 的模中,有多少棵树 \(T\) 与 \(f(T)=Q\) 相等。这里,如果存在一对顶点 \((u,v)\) ,使得一棵树中的顶点 \(u\) 与顶点 \(v\) 之间有一条边,而另一棵树中没有边,那么这两棵树就是不同的。
约束条件
- \(1\le N\le2\times10 ^ 5\)
- \(1\le Q _ i\le N\\ (1\le i\le N)\)
- \(Q _ i\ne Q _ j\\ (1\le i\lt j\le N)\)
- \(Q _ 1=1\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\)
\(Q_1\),\(Q_2\),\(\ldots\),\(Q_N\)
输出
输出模数为 \(998244353\) 的树 \(T\) 中 \(f(T)=Q\) 的数目。
输入样本 1
5
1 3 4 2 5
样本输出 1
8
例如,如果 \(T\) 是下面的树,那么 \(f(T)=Q\) 。

查找 \(f(T)\) 的过程如下图所示。

包括这棵树在内,以下八棵树都满足条件。

因此,输出 8 。
输入样本 2
20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
样本输出 2
868586527
输出模数 \(998244353\) 满足条件的树的数量。
输入样本 3
30
1 16 23 14 18 10 12 21 27 30 17 28 4 9 20 13 22 11 19 3 25 26 6 7 2 8 5 24 15 29
输出样本 3
910753763
题意
给一个排列 \(Q\)(\(Q_1 = 1\)),求有多少棵树 \(T\),使得按以下规则生成的序列恰好是 \(Q\):
- 初始 \(S = \{1\}\),\(P = ()\)
- 每次取 \(S\) 中最小值 \(x\),加入 \(P\),把 \(x\) 的未加入 \(P\) 的邻居加入 \(S\)
答案对 \(998244353\) 取模。
思路
先理解 \(f(T)\) 在做什么
这个生成过程其实就是:每次从候选集合里挑最小的点扩展。
要让 \(f(T) = Q\),意味着:
- 第 \(i\) 次取出的点必须是 \(Q_i\)
- 而且此时 \(S\) 中的最小值必须恰好是 \(Q_i\)
关键观察:每个点的「父节点」约束
考虑 \(Q_i\)(\(i \ge 2\)),它必须是被某个已经加入 \(P\) 的点作为邻居引入 \(S\) 的。设这个点是 \(u\),那么 \(u\) 就是 \(Q_i\) 在树上的父节点。
这个 \(u\) 必须满足什么条件?
① \(u\) 在 \(Q\) 中的位置比 \(Q_i\) 靠前。
因为 \(u\) 要先被加入 \(P\),才能把 \(Q_i\) 引入 \(S\)。
② \(u\) 到 \(Q_i\) 之间所有点的值都大于 \(Q_i\)。
否则,比如中间有个 \(Q_j < Q_i\),那在 \(Q_i\) 被取出之前,\(Q_j\) 会先被取出(因为 \(S\) 取最小),顺序就乱了。
③ 中间的点不能被「跳过」而先被别的点引入。
实际上,只要满足 ②,中间那些点必然是通过 \(u\) 之外的路径引入 \(S\) 的,不会干扰 \(Q_i\) 的取出顺序。
所以结论是:
\(Q_i\) 可以选择的父节点,是 \(Q\) 中位置在 \(i\) 左边、且从它到 \(i\) 之间所有点的值都 \(> Q_i\) 的那些点。
计数
设这些可选父节点的数量为 \(c_i\)。
每个 \(Q_i\)(\(i \ge 2\))独立选择父节点,所以总的树的数量是:
$\text{ans} = \prod_{i=2}^{N} c_i
为什么独立?因为一旦每个点选定了父节点,树的结构就唯一确定了,而且每条边都满足约束。
怎么快速算 \(c_i\)
观察条件:从 \(i\) 往左看,跳过所有比 \(Q_i\) 大的点,直到遇到第一个比 \(Q_i\) 小的点(或者走到最左边)。
- 如果遇到第一个比 \(Q_i\) 小的点在位置 \(j\),那么可选父节点是 \(j+1, j+2, \dots, i-1\),共 \(i - j\) 个
- 如果左边没有比 \(Q_i\) 小的,可选父节点是 \(1, 2, \dots, i-1\),共 \(i - 1\) 个
这正是单调栈能做的事:维护一个递减栈(栈内元素值递减),从左到右扫描,遇到 \(Q_i\) 就把栈顶所有小于 \(Q_i\) 的弹出,剩下的栈顶就是「左边第一个比 \(Q_i\) 小的位置」。
复杂度
- 每个元素进出栈一次,\(O(N)\)
- 总时间 \(O(N)\),空间 \(O(N)\)
\(N \le 2 \times 10^5\),秒过。
代码
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN = 2e5 + 10;
const int MOD = 998244353;
int n;
int tp;
int ans;
int q[MAXN];
int l[MAXN];
int st[MAXN];
signed main ()
{
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
ios::sync_with_stdio (false);
cin.tie (0);
cout.tie (0);
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> q[i];
}
tp = 0;
for (int i = 1; i <= n; i++)
{
// printf ("--------------------第 %d 次开始--------------------\n", i);
//
while (tp && q[st[tp]] < q[i])
{
tp--;
}
//
// printf ("tp = %d\n", tp);
//
if (tp > 0)
{
// printf ("因为 tp = %d 大于 0,所以 l[i](%d) -> st[tp](%d)\n", tp, l[i], st[tp]);
//
l[i] = st[tp];
}
else
{
// printf ("因为 tp = %d 不大于 0,所以 l[i](%d) -> 0\n", tp, l[i]);
//
l[i] = 0;
}
tp++;
st[tp] = i;
// printf ("st[tp] = %d\n", st[tp]);
//
// printf ("tp = %d,st[tp] = %d\n", tp, st[tp]);
//
// printf ("--------------------第 %d 次结束--------------------\n", i);
}
ans = 1;
for (int i = 2; i <= n; i++)
{
int ct;
if (l[i] == 0)
{
ct = i - 1;
}
else
{
ct = i - l[i];
}
ans = ans * ct % MOD;
}
cout << ans << "\n";
return 0;
}
后记
思路通了之后代码很短,删除调试代码之后只有80行,但是考场上脑子卡壳了,竟然没有调试出来。
G - Division Point Hull
翻译
得分: $625$ 分问题陈述
坐标平面上有 \(N\) 个点 \(P_1,P_2,\dots,P_N\) 。点 \(P_i\) 的坐标为 \((X_i,Y_i)\) 。
给你正整数 \(p,q\) 。设点 \(Q_{i,j}\) 是线段 \(P_iP_j\) 的内部平分线,其比例为 \(p:q\) 。其中,若 \(P_i=P_j\) ,则 \(Q_{i,j}=P_i\) 。
求满足 \(1 \leq i \lt j \leq N\) 的所有一对正整数 \((i,j)\) 的 \(Q_{i,j}\) 凸面的面积。
约束条件
- \(2 \leq N \leq 10^5\)
- \(1 \leq p \lt q \leq 10\)
- \(|X_i|\leq 10^7\)
- \(|Y_i|\leq 10^7\)
- 所有输入值均为整数。
输入
输入内容由标准输入法提供,格式如下
\(N\),\(p\),\(q\)
\(X_1\) \(Y_1\)
\(X_2\) \(Y_2\)
\(\vdots\)
\(X_N\) \(Y_N\)
输出
可以证明,在这个问题的约束条件下,要找到的凸壳的面积是有理数。当面积以不可还原分数 \(\dfrac{x}{y}\\ (x \geq 0, y \geq 1)\) 表示时,依次输出 \(x\) 和 \(y\) ,中间用空格隔开。
输入示例 1
4 1 2
-2 4
1 1
-3 -2
4 0
样本输出 1
59 6
我们得到 \(Q_{1,2}=\left(-1,3\right),Q_{1,3}=\left(-\frac{7}{3},2\right),Q_{1,4}=\left(0,\frac{8}{3}\right),Q_{2,3}=\left(-\frac{1}{3},0\right),Q_{2,4}=\left(2,\frac{2}{3}\right),Q_{3,4}=\left(-\frac{2}{3},-\frac{4}{3}\right)\) 。
它们的凸面体是按此顺序连接 \(Q_{1,2},Q_{1,3},Q_{3,4},Q_{2,4},Q_{1,4}\) 形成的五边形,其面积为 \(\frac{59}{6}\) 。

输入样本 2
3 3 4
11 -7
2 8
-4 18
输出样本 2
0 1
凸壳的面积可能是 \(0\) 。
输入样本 3
10 5 7
-3677189 -8603516
3324282 8371380
-4445534 -865546
-1235744 -6761030
2732080 -9194939
8510740 4384715
-7326815 2451526
-2079912 1054509
2072791 -8408897
-4437202 -5184973
输出样本 3
6746232144385823 48
官方传送门
不在能力范围内,不会
本文来自博客园,作者:栤酱,转载请注明原文链接:https://www.cnblogs.com/wth1123/p/23197899

浙公网安备 33010602011771号