写着玩,思路什么我的看 J a v a \mathrm{Java} Java 组那边。
刚才确认了一下, C A \mathrm{CA} CA 组有的 J a v a \mathrm{Java} Java 全有。
#A 纯质数
本题总分:5 分
问题描述
如果一个正整数只有
1
1
1 和它本身两个约数,则称为一个质数(又称素数)。
前几个质数是:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
,
23
,
29
,
31
,
37
,
⋅
⋅
⋅
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, · · ·
2,3,5,7,11,13,17,19,23,29,31,37,⋅⋅⋅ 。
如果一个质数的所有十进制数位都是质数,我们称它为纯质数。例如:
2
,
3
,
5
,
7
,
23
,
37
2, 3, 5, 7, 23, 37
2,3,5,7,23,37 都是纯质数,而
11
,
13
,
17
,
19
,
29
,
31
11, 13, 17, 19, 29, 31
11,13,17,19,29,31 不是纯质数。当然
1
,
4
,
35
1, 4, 35
1,4,35 也不是纯质数。
请问,在
1
1
1 到
20210605
20210605
20210605 中,有多少个纯质数?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
1903
#include <iostream>
#include <vector>
#define N 20210605
using namespace std;
int main(){
bool marked[N + 1] = {1, 1};
vector<int> primes;
int ans = 0;
for (int i = 2; i <= N; ++i) {
if (!marked[i]) {
primes.push_back(i);
bool flag = 1;
for (int k = i; k > 0; k /= 10)
if (marked[k % 10]) { flag = 0; break; }
if (flag) ans++;
}
for (int p : primes) {
if (p * i > N) break;
marked[p * i] = 1;
if (i % p == 0) break;
}
}
cout << ans << endl;
}
#B 完全日期
本题总分:5 分
问题描述
如果一个日期中年月日的各位数字之和是完全平方数,则称为一个完全日期。
例如:
2021
2021
2021 年
6
6
6 月
5
5
5 日的各位数字之和为
2
+
0
+
2
+
1
+
6
+
5
=
16
2 + 0 + 2 + 1 + 6 + 5 = 16
2+0+2+1+6+5=16,而
16
16
16 是一个完全平方数,它是
4
4
4 的平方。所以
2021
2021
2021 年
6
6
6 月
5
5
5 日是一个完全日期。
例如:
2021
2021
2021 年
6
6
6 月
23
23
23 日的各位数字之和为
2
+
0
+
2
+
1
+
6
+
2
+
3
=
16
2 + 0 + 2 + 1 + 6 + 2 + 3 = 16
2+0+2+1+6+2+3=16,是一个完全平方数。所以
2021
2021
2021 年
6
6
6 月
23
23
23 日也是一个完全日期。
请问,从
2001
2001
2001 年
1
1
1 月
1
1
1 日到
2021
2021
2021 年
12
12
12 月
31
31
31 日中,一共有多少个完全日期?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
977
#include <iostream>
using namespace std;
int calc(int n) {
int res = 0;
do
res += n % 10;
while (n /= 10);
return res;
}
bool isPerfect(int num) { return num == 3 * 3 || num == 4 * 4 || num == 5 * 5; }
bool isLeapYear(int year) { return !(year % 100 ? year % 4 : year % 400); }
int main(){
int bigMonth[]{ 1, 3, 5, 7, 8, 1 + 0, 1 + 2 };
int smallMonth[]{ 4, 6, 9, 1 + 1 }, ans = 0;
int calendar[9 + 2 + 9 + 1]{0};
for (int day = 1; day <= 31; ++day) {
for (int month : bigMonth) calendar[month + calc(day)]++;
if (day <= 30) for (int month : smallMonth) calendar[month + calc(day)]++;
if (day <= 28) calendar[2 + calc(day)]++;
}
for (int year = 2001; year <= 2021; ++year) {
if (isLeapYear(year))
if (isLeapYear(year + 2 + 2 + 9)) ans++;
for (int i = 0; i < 9 + 2 + 9 + 1; i++) {
if (calendar[i] == 0) continue;
if (isPerfect(calc(year) + i)) ans += calendar[i];
}
}
cout << ans << endl;
}
#C 最小权值
本题总分:10 分
问题描述
对于一棵有根二叉树
T
T
T,小蓝定义这棵树中结点的权值
W
(
T
)
W(T)
W(T) 如下:
空子树的权值为
0
0
0。
如果一个结点
v
v
v 有左子树
L
L
L, 右子树
R
R
R,分别有
C
(
L
)
C(L)
C(L) 和
C
(
R
)
C(R)
C(R) 个结点,则
W
(
v
)
=
1
+
2
W
(
L
)
+
3
W
(
R
)
+
(
C
(
L
)
)
2
C
(
R
)
W(v) = 1 + 2W(L) + 3W(R) + (C(L))^{2} C(R)
W(v)=1+2W(L)+3W(R)+(C(L))2C(R)。
树的权值定义为树的根结点的权值。
小蓝想知道,对于一棵有
2021
2021
2021 个结点的二叉树,树的权值最小可能是多少?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
2653631372
#include <iostream>
#define N 2021
#define INF 0x3C3C3C3C3C3C3C3C
using namespace std;
int main(){
long long W[N + 1]{0};
for (int i = 1; i <= N; i++) {
W[i] = INF;
for (int l = 0, r = i - 1; l < i; l++, r--)
W[i] = min(W[i], 1 + 2 * W[l] + 3 * W[r] + l * l * r);
}
cout << W[N] << endl;
}
#D 覆盖
本题总分:10 分
问题描述
小蓝有一个国际象棋的棋盘,棋盘的大小为
8
×
8
8 × 8
8×8,即由
8
8
8 行
8
8
8 列共
64
64
64 个方格组成。棋盘上有美丽的图案,因此棋盘旋转后与原来的棋盘不一样。
小蓝有很多相同的纸片,每张纸片正好能覆盖棋盘的两个相邻方格。小蓝想用
32
32
32 张纸片正好将棋盘完全覆盖,每张纸片都覆盖其中的两个方格。
小蓝发现,有很多种方案可以实现这样的覆盖。如果棋盘比较小,方案数相对容易计算,比如当棋盘是
2
×
2
2 × 2
2×2 时有两种方案,当棋盘是
4
×
4
4 × 4
4×4 时有
36
36
36 种方案。但是小蓝算不出他自己的这个
8
×
8
8 × 8
8×8 的棋盘有多少种覆盖方案。
请帮小蓝算出对于这个
8
×
8
8 × 8
8×8 的棋盘总共有多少种覆盖方案。
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
12988816
#include <iostream>
#define N 8
using namespace std;
int dp[N + 1][1 << N];
bool check[1 << N], flag, even;
int main(){
for (int i = 0; i < 1 << N; i++) {
flag = even = 1;
for (int j = 0; j < N; j++)
if ((i >> j) & 1) flag &= even, even = 1;
else even = !even;
check[i] = flag & even;
}
dp[0][0] = 1;
for (int i = 1; i <= N; i++)
for (int j = 0; j < 1 << N; j++) {
dp[i][j] = 0;
for (int k = 0; k < 1 << N; k++)
if (!(j & k) && check[j | k])
dp[i][j] += dp[i - 1][k];
}
cout << dp[N][0] << endl;
}
#E 123
时间限制: 1.0 1.0 1.0s 内存限制: 256.0 256.0 256.0MB 本题总分: 15 15 15分
问题描述
小蓝发现了一个有趣的数列,这个数列的前几项如下:
1
,
1
,
2
,
1
,
2
,
3
,
1
,
2
,
3
,
4
,
.
.
.
1, 1, 2, 1, 2, 3, 1, 2, 3, 4, ...
1,1,2,1,2,3,1,2,3,4,...
小蓝发现,这个数列前
1
1
1 项是整数
1
1
1,接下来
2
2
2 项是整数
1
1
1 至
2
2
2,接下来
3
3
3 项是整数
1
1
1 至
3
3
3,接下来
4
4
4 项是整数
1
1
1 至
4
4
4,依次类推。
小蓝想知道,这个数列中,连续一段的和是多少。
输入格式
输入的第一行包含一个整数
T
T
T,表示询问的个数。
接下来
T
T
T 行,每行包含一组询问,其中第
i
i
i 行包含两个整数
l
i
l_{i}
li 和
r
i
r_{i}
ri,表示询问数列中第
l
i
l_{i}
li 个数到第
r
i
r_{i}
ri 个数的和。
输出格式
输出 T T T 行,每行包含一个整数表示对应询问的答案。
测试样例1
Input:
3
1 1
1 3
5 8
Output:
1
4
8
评测用例规模与约定
对于
10
10
10% 的评测用例,
1
≤
T
≤
30
,
1
≤
l
i
≤
r
i
≤
100
1 \leq T \leq 30, 1 \leq l_{i} \leq r_{i} ≤ 100
1≤T≤30,1≤li≤ri≤100。
对于
20
20
20% 的评测用例,
1
≤
T
≤
100
,
1
≤
l
i
≤
r
i
≤
1000
1 \leq T \leq 100, 1 \leq l_{i} \leq r_{i} ≤ 1000
1≤T≤100,1≤li≤ri≤1000。
对于
40
40
40% 的评测用例,
1
≤
T
≤
1000
,
1
≤
l
i
≤
r
i
≤
1
0
6
1 \leq T \leq 1000, 1 \leq l_{i} \leq r_{i} ≤ 10^{6}
1≤T≤1000,1≤li≤ri≤106。
对于
70
70
70% 的评测用例,
1
≤
T
≤
10000
,
1
≤
l
i
≤
r
i
≤
1
0
9
1 \leq T \leq 10000, 1 \leq l_{i} \leq r_{i} ≤ 10^{9}
1≤T≤10000,1≤li≤ri≤109。
对于
80
80
80% 的评测用例,
1
≤
T
≤
1000
,
1
≤
l
i
≤
r
i
≤
1
0
12
1 \leq T \leq 1000, 1 \leq l_{i} \leq r_{i} ≤ 10^{12}
1≤T≤1000,1≤li≤ri≤1012。
对于
90
90
90% 的评测用例,
1
≤
T
≤
10000
,
1
≤
l
i
≤
r
i
≤
1
0
12
1 \leq T \leq 10000, 1 \leq l_{i} \leq r_{i} ≤ 10^{12}
1≤T≤10000,1≤li≤ri≤1012。
对于所有评测用例,
1
≤
T
≤
100000
,
1
≤
l
i
≤
r
i
≤
1
0
12
1 \leq T \leq 100000, 1 \leq l_{i} \leq r_{i} ≤ 10^{12}
1≤T≤100000,1≤li≤ri≤1012。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1414222;
ll row[N], col[N];
ll sum(ll r) {
ll k = sqrt(r << 1);
while (k * (k + 1) / 2 > r) k--;
return col[k] + row[r - row[k]];
}
int main(){
for (int i = 1; i <= N; ++i) {
row[i] = row[i - 1] + i;
col[i] = col[i - 1] + row[i];
}
ll l, r;
cin >> l;
while (cin >> l >> r)
cout << sum(r) - sum(l - 1) << endl;
}
用 c p p \mathrm{cpp} cpp 写的时候发现还能优化一个对数下来,
他还在内卷!
#F 异或变换
时间限制: 1.0s 内存限制: 256.0MB 本题总分:15 分
问题描述
小蓝有一个
01
01
01 串
s
=
s
1
s
2
s
3
⋅
⋅
⋅
s
n
s = s_{1} s_{2} s_{3} · · · s_{n}
s=s1s2s3⋅⋅⋅sn。
以后每个时刻,小蓝要对这个
01
01
01 串进行一次变换。每次变换的规则相同。
对于
01
01
01 串
s
=
s
1
s
2
s
3
⋅
⋅
⋅
s
n
s = s_{1} s_{2} s_{3} · · · s_{n}
s=s1s2s3⋅⋅⋅sn,变换后的
01
01
01 串
s
′
=
s
1
′
s
2
′
s
3
′
⋯
s
n
′
s^′ = s^′_{1}s^′_{2}s^′_{3} \cdots s^′_{n}
s′=s1′s2′s3′⋯sn′ 为:
s
1
′
=
s
1
s^′_{1} = s_{1}
s1′=s1;
s
i
′
=
s
i
−
1
⊕
s
i
s^′_{i} = s_{i−1} ⊕ s_{i}
si′=si−1⊕si。
其中
a
⊕
b
a ⊕ b
a⊕b 表示两个二进制的异或,当
a
a
a 和
b
b
b 相同时结果为
0
0
0,当 a 和 b不同时结果为
1
1
1。
请问,经过
t
t
t 次变换后的
01
01
01 串是什么?
输入格式
输入的第一行包含两个整数
n
,
t
n, t
n,t,分别表示
01
01
01 串的长度和变换的次数。
第二行包含一个长度为
n
n
n 的
01
01
01 串。
输出格式
输出一行包含一个 01 01 01 串,为变换后的串。
测试样例1
Input:
5 3
10110
Output:
11010
Explanation:
初始时为 10110,变换 1 次后变为 11101,变换 2 次后变为 10011,变换 3 次后变为 11010。
评测用例规模与约定
对于
40
40
40% 的评测用例,
1
≤
n
≤
100
,
1
≤
t
≤
1000
1 ≤ n ≤ 100, 1 ≤ t ≤ 1000
1≤n≤100,1≤t≤1000。
对于
80
80
80% 的评测用例,
1
≤
n
≤
1000
,
1
≤
t
≤
1
0
9
1 ≤ n ≤ 1000, 1 ≤ t ≤ 10^{9}
1≤n≤1000,1≤t≤109。
对于所有评测用例,
1
≤
n
≤
10000
,
1
≤
t
≤
1
0
18
1 ≤ n ≤ 10000, 1 ≤ t ≤ 10^{18}
1≤n≤10000,1≤t≤1018。
#include <bits/stdc++.h>
using namespace std;
char buff[10005];
int main(){
long long n, t;
cin >> n >> t >> buff;
for (int i = n - 1; i >= 0; i--) {
char c = buff[i];
for (int j = 1; j <= i && j <= t; ++j)
if ((t & j) == j && buff[i - j] == '1') c ^= 1;
buff[i] = c;
}
cout << buff << endl;
}
#G 冰山
时间限制: 1.0 1.0 1.0s 内存限制: 256.0 256.0 256.0MB 本题总分: 20 20 20 分
问题描述
一片海域上有一些冰山,第
i
i
i 座冰山的体积为
V
i
V_{i}
Vi。
随着气温的变化,冰山的体积可能增大或缩小。第
i
i
i 天,每座冰山的变化量都是
X
i
X_{i}
Xi。当
X
i
>
0
X_{i} > 0
Xi>0 时,所有冰山体积增加
X
i
X_{i}
Xi;当
X
i
<
0
X_{i} < 0
Xi<0 时,所有冰山体积减少
−
X
i
−X_{i}
−Xi;当
X
i
=
0
X_{i} = 0
Xi=0 时,所有冰山体积不变。
如果第
i
i
i 天某座冰山的体积变化后小于等于
0
0
0,则冰山会永远消失。
冰山有大小限制
k
k
k。如果第
i
i
i 天某座冰山
j
j
j 的体积变化后
V
j
V_{j}
Vj 大于
k
k
k,则它会分裂成一个体积为
k
k
k 的冰山和
V
j
−
k
V_{j} − k
Vj−k 座体积为
1
1
1 的冰山。
第
i
i
i 天结束前(冰山增大、缩小、消失、分裂完成后),会漂来一座体积为
Y
i
Y_{i}
Yi 的冰山(
Y
i
=
0
Y_{i} = 0
Yi=0 表示没有冰山漂来)。
小蓝在连续的
m
m
m 天对这片海域进行了观察,并准确记录了冰山的变化。小蓝想知道,每天结束时所有冰山的体积之和(包括新漂来的)是多少。
由于答案可能很大,请输出答案除以
998244353
998244353
998244353 的余数。
输入格式
输入的第一行包含三个整数
n
,
m
,
k
n, m, k
n,m,k,分别表示初始时冰山的数量、观察的天数以及冰山的大小限制。
第二行包含
n
n
n 个整数
V
1
,
V
2
,
⋅
⋅
⋅
,
V
n
V_{1}, V_{2}, · · · , V_{n}
V1,V2,⋅⋅⋅,Vn,表示初始时每座冰山的体积。
接下来
m
m
m 行描述观察的
m
m
m 天的冰山变化。其中第
i
i
i 行包含两个整数
X
i
,
Y
i
X_{i}, Y_{i}
Xi,Yi,意义如前所述。
输出格式
输出 m m m 行,每行包含一个整数,分别对应每天结束时所有冰山的体积之和除以 998244353 998244353 998244353 的余数。
测试样例1
Input:
1 3 6
1
6 1
2 2
-1 1
Output:
8
16
11
Explanation:
在本样例说明中,用 [a1, a2, · · · , an] 来表示每座冰山的体积。
初始时的冰山为 [1]。
第 1 天结束时,有 3 座冰山:[1, 1, 6]。
第 2 天结束时,有 6 座冰山:[1, 1, 2, 3, 3, 6]。
第 3 天结束时,有 5 座冰山:[1, 1, 2, 2, 5]。
评测用例规模与约定
对于
40
40
40% 的评测用例,
n
,
m
,
k
≤
2000
n, m, k ≤ 2000
n,m,k≤2000;
对于
60
60
60% 的评测用例,
n
,
m
,
k
≤
20000
n, m, k ≤ 20000
n,m,k≤20000;
对于所有评测用例,
1
≤
n
,
m
≤
100000
,
1
≤
k
≤
1
0
9
,
1
≤
V
i
≤
k
,
0
≤
Y
i
≤
k
,
−
k
≤
X
i
≤
k
1 ≤ n, m ≤ 100000, 1 ≤ k ≤ 10^{9}, 1 ≤ V_{i} ≤ k, 0 ≤ Y_{i} ≤ k,−k ≤ X_{i} ≤ k
1≤n,m≤100000,1≤k≤109,1≤Vi≤k,0≤Yi≤k,−k≤Xi≤k。
\\OJ上过不去,再调整一下
#H 翻转括号序列
时间限制: 2.0 2.0 2.0s 内存限制: 512.0 512.0 512.0MB 本题总分: 20 20 20分
问题描述
给定一个长度为
n
n
n 的括号序列,要求支持两种操作:
1
1
1. 将
[
L
i
,
R
i
]
[L_{i}, R_{i}]
[Li,Ri] 区间内(序列中的第
L
i
L_{i}
Li 个字符到第
R
i
R_{i}
Ri 个字符)的括号全部翻转(左括号变成右括号,右括号变成左括号)。
2
2
2. 求出以 Li 为左端点时,最长的合法括号序列对应的
R
i
R_{i}
Ri (即找出最大的
R
i
R_{i}
Ri 使
[
L
i
,
R
i
]
[L_{i}, R_{i}]
[Li,Ri] 是一个合法括号序列)。
输入格式
输入的第一行包含两个整数
n
,
m
n, m
n,m,分别表示括号序列长度和操作次数。
第二行包含给定的括号序列,括号序列中只包含左括号和右括号。
接下来
m
m
m 行,每行描述一个操作。如果该行为
“
1
L
i
R
i
”
“1 L_{i} R_{i}”
“1LiRi”,表示第一种操作,区间为
[
L
i
,
R
i
]
[L_{i}, R_{i}]
[Li,Ri];如果该行为
“
2
L
i
”
“2 L_{i}”
“2Li” 表示第二种操作,左端点为
L
i
L_{i}
Li。
输出格式
对于每个第二种操作,输出一行,表示对应的 R i R_{i} Ri。如果不存在这样的 R i R_{i} Ri,请输出 0 0 0。
测试样例1
Input:
7 5
((())()
2 3
2 2
1 3 5
2 3
2 1
Output:
4
7
0
0
评测用例规模与约定
对于
20
20
20% 的评测用例,
n
,
m
≤
5000
n, m \leq 5000
n,m≤5000;
对于
40
40
40% 的评测用例,
n
,
m
≤
30000
n, m \leq 30000
n,m≤30000;
对于
60
60
60% 的评测用例,
n
,
m
≤
100000
n, m \leq 100000
n,m≤100000;
对于所有评测用例,
1
≤
n
≤
1
0
6
,
1
≤
m
≤
2
×
1
0
5
1 \leq n \leq 10^{6}, 1 \leq m \leq 2 × 10^{5}
1≤n≤106,1≤m≤2×105。
\\OJ上过不去,再调整一下
#I 异或三角
时间限制: 1.0 1.0 1.0s 内存限制: 256.0 256.0 256.0MB 本题总分: 25 25 25分
问题描述
给定
T
T
T 个数
n
1
,
n
2
,
⋅
⋅
⋅
,
n
T
n_{1}, n_{2}, · · · , n_{T}
n1,n2,⋅⋅⋅,nT,对每个
n
i
n_{i}
ni 请求出有多少组
a
,
b
,
c
a, b, c
a,b,c 满足:
1
1
1.
1
≤
a
,
b
,
c
≤
n
i
1 \leq a, b, c \leq n_{i}
1≤a,b,c≤ni;
2
2
2.
a
⊕
b
⊕
c
=
0
a \oplus b \oplus c = 0
a⊕b⊕c=0,其中
⊕
\oplus
⊕ 表示二进制按位异或;
3
3
3. 长度为
a
,
b
,
c
a, b, c
a,b,c 的三条边能组成一个三角形。
输入格式
输入的第一行包含一个整数
T
T
T。
接下来
T
T
T 行每行一个整数,分别表示
n
1
,
n
2
,
⋅
⋅
⋅
,
n
T
n_{1}, n_{2}, · · · , n_{T}
n1,n2,⋅⋅⋅,nT。
输出格式
输出 T T T 行,每行包含一个整数,表示对应的答案。
测试样例1
Input:
2
6
114514
Output:
6
11223848130
评测用例规模与约定
对于
10
10
10% 的评测用例,
T
=
1
,
1
≤
n
i
≤
200
T = 1, 1 \leq n_{i} \leq 200
T=1,1≤ni≤200;
对于
20
20
20% 的评测用例,
T
=
1
,
1
≤
n
i
≤
2000
T = 1, 1 \leq n_{i} \leq 2000
T=1,1≤ni≤2000;
对于
50
50
50% 的评测用例,
T
=
1
,
1
≤
n
i
≤
2
20
T = 1, 1 \leq n_{i} \leq 2^{20}
T=1,1≤ni≤220;
对于
60
60
60% 的评测用例,
1
≤
T
≤
100000
,
1
≤
n
i
≤
2
20
1 \leq T \leq 100000, 1 \leq n_{i} \leq 2^{20}
1≤T≤100000,1≤ni≤220;
对于所有评测用例,
1
≤
T
≤
100000
,
1
≤
n
i
≤
2
30
1 \leq T ≤ 100000, 1 \leq n_{i} \leq 2^{30}
1≤T≤100000,1≤ni≤230。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll hb[0x20], cb[0x20];
int highBit(int n) {
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
return n - (n >> 1);
}
ll calcCountBit(int n) {
if (n == 0) return 0;
int m = highBit(n);
ll ans = cb[(int)log2(m)];
if (n != m)
ans += calcCountBit(n - m) << 1;
return ans;
}
int main(){
cb[0] = 1;
for (int i = 1; i < 0x20; i++) {
hb[i] = (hb[i - 1] << 2) | 1;
cb[i] = cb[i - 1] * 3 - 1;
}
int n, m, k;
cin >> n;
while (cin >> n) {
k = log2(n);
m = n - (1 << k);
cout <<
6 * (
(n + 3ll) * n / 2 -
(calcCountBit(n)) -
hb[k] - (m + 1ll) * (1 << k))
<< endl;
}
}
#J 积木
时间限制: 2.0 2.0 2.0s 内存限制: 256.0 256.0 256.0MB 本题总分: 25 25 25分
问题描述
小蓝有大量正方体的积木(所有积木完全相同),他准备用积木搭一个巨大的图形。
小蓝将积木全部平铺在地面上,而不垒起来,以便更稳定。他将积木摆成一行一行的,每行的左边对齐,形成最终的图形。
第一行小蓝摆了
H
1
=
w
H_{1} = w
H1=w 块积木。从第二行开始,第
i
i
i 行的积木数量
H
i
H_{i}
Hi 都至少比上一行多
L
L
L,至多比上一行多
R
R
R(当
L
=
0
L = 0
L=0 时表示可以和上一行的积木数量相同),即
H
i
−
1
+
L
≤
H
i
≤
H
i
−
1
+
R
H_{i−1} + L ≤ H_{i} ≤ H_{i−1} + R
Hi−1+L≤Hi≤Hi−1+R。
给定
x
,
y
x, y
x,y 和
z
z
z,请问满足以上条件的方案中,有多少种方案满足第
y
y
y 行的积木数量恰好为第
x
x
x 行的积木数量的
z
z
z 倍。
输入格式
输入一行包含 7 7 7 个整数 n , w , L , R , x , y , z n,w, L, R, x, y, z n,w,L,R,x,y,z,意义如上所述。
输出格式
输出一个整数, 表示满足条件的方案数,答案可能很大,请输出答案除以 998244353 998244353 998244353 的余数。
测试样例1
Input:
5 1 1 2 2 5 3
Output:
4
样例说明1
符合条件的积木如图所示
测试样例2
Input:
233 5 1 8 100 215 3
Output:
308810105
评测用例规模与约定
对于
10
10
10% 的评测用例,
1
≤
n
≤
10
,
1
≤
w
≤
10
,
0
≤
L
≤
R
≤
3
1 ≤ n ≤ 10, 1 ≤ w ≤ 10, 0 ≤ L ≤ R ≤ 3
1≤n≤10,1≤w≤10,0≤L≤R≤3;
对于
20
20
20% 的评测用例,
1
≤
n
≤
20
,
1
≤
w
≤
10
,
0
≤
L
≤
R
≤
4
1 ≤ n ≤ 20, 1 ≤ w ≤ 10, 0 ≤ L ≤ R ≤ 4
1≤n≤20,1≤w≤10,0≤L≤R≤4;
对于
35
35
35% 的评测用例,
1
≤
n
≤
500
,
0
≤
L
≤
R
≤
10
1 ≤ n ≤ 500, 0 ≤ L ≤ R ≤ 10
1≤n≤500,0≤L≤R≤10;
对于
50
50
50% 的评测用例,
1
≤
n
≤
5000
,
0
≤
L
≤
R
≤
10
1 ≤ n ≤ 5000, 0 ≤ L ≤ R ≤ 10
1≤n≤5000,0≤L≤R≤10;
对于
60
60
60% 的评测用例,
1
≤
n
≤
20000
,
0
≤
L
≤
R
≤
10
1 ≤ n ≤ 20000, 0 ≤ L ≤ R ≤ 10
1≤n≤20000,0≤L≤R≤10;
对于
70
70
70% 的评测用例,
1
≤
n
≤
50000
,
0
≤
L
≤
R
≤
10
1 ≤ n ≤ 50000, 0 ≤ L ≤ R ≤ 10
1≤n≤50000,0≤L≤R≤10;
对于
85
85
85% 的评测用例,
1
≤
n
≤
300000
,
0
≤
L
≤
R
≤
10
1 ≤ n ≤ 300000, 0 ≤ L ≤ R ≤ 10
1≤n≤300000,0≤L≤R≤10;
对于所有评测用例,
1
≤
n
≤
500000
,
1
≤
w
≤
1
0
9
,
0
≤
L
≤
R
≤
40
,
1
≤
x
<
y
≤
n
,
0
≤
z
≤
1
0
9
1 ≤ n ≤ 500000, 1 ≤ w ≤ 10^{9}, 0 ≤ L ≤ R ≤ 40, 1 ≤ x < y ≤ n, 0 ≤ z ≤ 10^{9}
1≤n≤500000,1≤w≤109,0≤L≤R≤40,1≤x<y≤n,0≤z≤109。
//不会