Codeforces Round 640 (Div. 4) 题解
A. Sum of Round Numbers
题目大意：
给你一个整数 n , 1 < = n < = 1 0 4 n, 1 <= n <= 10^4 n,1<=n<=104，问最少拆成几个四舍五入数的和
四舍五入数的定义为：除了最高位其它位都为0的整数
例如，以下数字都是四舍五入数： 4000 4000 4000 , 1 1 1 , 9 9 9 , 800 800 800 , 90 90 90
下列数字不是： 110 110 110 , 707 707 707 , 222 222 222 , 1001 1001 1001 .
样例输入：
5
5009
7
9876
10000
10
样例输出
2
5000 9
1
7
4
800 70 6 9000
1
10000
1
10
思路
从右往左依次判断每一位，遇到不为0的数位就拆分
代码
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n; cin >> n;
vector<int> a;
for(int i = 10; i / 10 <= n; i *= 10) {
if(n % i != 0) {
a.push_back(n % i);
n -= n % i;
}
}
cout << a.size() << endl;
for(auto i : a) cout << i << " ";
cout << endl;
}
signed main() {
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
B. Same Parity Summands
题目大意：
给你两个正整数 n n n ( 1 ≤ n ≤ 1 0 9 1 \le n \le 10^9 1≤n≤109 )和 k k k ( 1 ≤ k ≤ 100 1 \le k \le 100 1≤k≤100 )。( 1 ≤ n ≤ 1 0 9 1 \le n \le 10^9 1≤n≤109 ) 和 k k k ( 1 ≤ k ≤ 100 1 \le k \le 100 1≤k≤100 )。
将数字 n n n 表示为具有相同奇偶性的 k k k 个正整数之和(除以 2 2 2 时具有相同的余数)。
换句话说，找出 a 1 , a 2 , … , a k a_1, a_2, \ldots, a_k a1,a2,…,ak ，使所有 a i > 0 a_i>0 ai>0 、 n = a 1 + a 2 + … + a k n = a_1 + a_2 + \ldots + a_k n=a1+a2+…+ak 和所有 a i a_i ai 同时为偶数或所有 a i a_i ai 同时为奇数。
如果不存在这样的表示，请报告。
样例输入：
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
样例输出
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120
思路
分类讨论
- k > n k > n k>n的情况一定不可能，直接输出 N O NO NO
- 如果 k , n k,n k,n的奇偶性一样，那么 n n n可以拆成 1 + 1 + 1... + ( n − k + 1 ) 1 + 1 + 1 ... + (n - k + 1) 1+1+1...+(n−k+1)
- 如果 n n n为奇数， k k k为偶数，那么不管是 k k k个奇数相加还是 k k k个偶数相加结果都为偶数，一定不可能，直接输出 N O NO NO
- 如果
n
n
n为偶数，
k
k
k为奇数
- k k k个奇数相加，结果一定为奇数，不行
- k k k个偶数相加，拆成形如 2 + 2 + 2... + ( n − k ∗ 2 + 2 ) 2 + 2 + 2 ... +(n - k * 2 + 2) 2+2+2...+(n−k∗2+2)的式子，需满足 2 ∗ k < = n 2 * k <= n 2∗k<=n
代码
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k; cin >> n >> k;
if(k > n) {
cout << "NO\n";
return ;
}
if(k % 2 == n % 2) {
cout << "YES\n";
for(int i = 2; i <= k; i++)
cout << 1 << " ";
cout << n - k + 1 << endl;
} else {
if(n % 2 == 0) {
if(k * 2 <= n) {
cout << "YES\n";
for(int i = 2; i <= k; i++)
cout << 2 << " ";
cout << n - (k + k - 2) << endl;
} else {
cout << "NO\n";
}
} else {
cout << "NO\n";
}
}
}
signed main() {
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
C. K-th Not Divisible by n
题目大意：
给定两个正整数 n n n 和 k k k 。打印不能被 n n n 整除的第 k k k个正整数 。
例如，如果 n = 3 n=3 n=3 n = 3 n = 3 n=3 和 k = 7 k=7 k=7 ，则所有不能被 3 3 3 整除的数为： 1 , 2 , 4 , 5 , 7 , 8 , 10 , 11 , 13 … 1, 2, 4, 5, 7, 8, 10, 11, 13 \dots 1,2,4,5,7,8,10,11,13… 。
其中第 7 7 7个数是 10 10 10 。
每个测试用例都是两个正整数 n n n ( 2 ≤ n ≤ 1 0 9 2 \le n \le 10^9 2≤n≤109 ) 和 k k k ( 1 ≤ k ≤ 1 0 9 1 \le k \le 10^9 1≤k≤109 )。
样例输入
6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1
样例输出
10
15
1999999999
113
1000000001
1
思路
我们把正整数拆成每行 n n n个数字，例如 n = 5 , k = 16 n = 5, k = 16 n=5,k=16
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
...
不难发现，只有每一行的最后一个数字能被 n n n 整除
我们先判断第 k k k 个不能被 n n n整除的数字在第几行
v = k / ( n − 1 ) v = k / (n - 1) v=k/(n−1)
两种情况：
- k / ( n − 1 ) k / (n - 1) k/(n−1)的余数为 0 0 0，那么说明在第 v v v行的倒数第二个，结果为 v ∗ n − 1 v * n - 1 v∗n−1
- 余数不为 0 0 0，那么往前加余数个位置即可，结果为 v ∗ n + k % ( n − 1 ) v * n + k \% (n - 1) v∗n+k%(n−1)
代码
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k; cin >> n >> k;
int vis = k / (n - 1);
if(k % (n - 1) == 0) cout << vis * n - 1 << endl;
else cout << (vis * n) + k % (n - 1) << endl;
}
signed main() {
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
D. Alice, Bob and Candies
题目大意：
一排有 n n n 颗糖果，从左到右从 1 1 1 到 n n n 进行编号。 第 i i i 个糖果的大小是 a i a_i ai 。
爱丽丝和鲍勃玩一个有趣又美味的游戏：他们吃糖果。爱丽丝从左到右吃糖，鲍勃从右到左吃糖。如果所有的糖果都吃完了，游戏就结束了。
这个过程是由动作组成的。在移动过程中，玩家从她/他的身边吃一个或多个糖果(Alice从左边吃，Bob从右边吃)。
爱丽丝先走了。在第一步中，她会吃 1 1 1 颗糖果(它的大小是 a 1 a_1 a1 )。然后，每个连续的移动，参与者交替——也就是说，鲍勃走第二步，然后是爱丽丝，然后是鲍勃，以此类推。
在每次移动中，玩家计算在当前移动中吃掉的糖果的总大小。一旦这个数字严格大于其他玩家在之前的移动中吃掉的糖果的总大小，当前玩家就会停止吃糖果，移动也就结束了。换句话说，在一次移动中，玩家吃掉尽可能少的糖果，这样在这次移动中吃掉的糖果大小的总和就严格大于另一个玩家在前一次移动中吃掉的糖果大小的总和。如果没有足够的糖果来进行移动，那么玩家就会吃掉所有剩余的糖果，游戏就会结束。
例如，如果 n = 11 n=11 n=11 和 a = [ 3 , 1 , 4 , 1 , 5 , 9 , 2 , 6 , 5 , 3 , 5 ] a=[3,1,4,1,5,9,2,6,5,3,5] a=[3,1,4,1,5,9,2,6,5,3,5] ，则：
-第1步：爱丽丝吃了一个大小为
3
3
3 的糖果，糖果的序列变成
[
1
,
4
,
1
,
5
,
9
,
2
,
6
,
5
,
3
,
5
]
[1,4,1,5,9,2,6,5,3,5]
[1,4,1,5,9,2,6,5,3,5] 。
-第2步：Alice在前一步中吃了
3
3
3 ，这意味着Bob必须吃
4
4
4 或更多。鲍勃吃了一个大小为
5
5
5 的糖果，糖果的序列就变成了
[
1
,
4
,
1
,
5
,
9
,
2
,
6
,
5
,
3
]
[1,4,1,5,9,2,6,5,3]
[1,4,1,5,9,2,6,5,3] 。
-第3步：鲍勃在前一步吃了
5
5
5 ，这意味着爱丽丝必须吃
6
6
6 或更多。爱丽丝吃了三颗总尺寸为
1
+
4
+
1
=
6
1+4+1=6
1+4+1=6 的糖果，糖果的序列变成了
[
5
,
9
,
2
,
6
,
5
,
3
]
[5,9,2,6,5,3]
[5,9,2,6,5,3] 。
-第4步：Alice在前一步吃了
6
6
6 ，这意味着Bob必须吃
7
7
7 或更多。Bob吃了两块总尺寸为
3
+
5
=
8
3+5=8
3+5=8 的糖果，糖果的序列变成了
[
5
,
9
,
2
,
6
]
[5,9,2,6]
[5,9,2,6] 。
-第5步：鲍勃在前一步吃了
8
8
8 ，这意味着爱丽丝必须吃
9
9
9 或更多。爱丽丝吃了两个总尺寸为
5
+
9
=
14
5+9=14
5+9=14 的糖果，糖果的序列变成
[
2
,
6
]
[2,6]
[2,6] 。
-第6步(最后一步)：爱丽丝在前一步吃了
14
14
14 ，这意味着鲍勃必须吃
15
15
15 或更多。这是不可能的，所以鲍勃吃掉了剩下的两块糖果，游戏结束了。
打印游戏中移动的数量和两个数字：
- a a a -游戏中爱丽丝吃掉的所有糖果的总大小；
- b b b - Bob在游戏中吃掉的所有糖果的总大小。
样例输入
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
样例输出
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
思路
根据题意模拟即可，注意细节
代码
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve() {
int n; cin >> n;
vector<int> v(n);
for(auto &i : v)
cin >> i;
int l = 0, r = n - 1;
int L = 0, R = 0, bef = 0, res = 0;
int visl = 0, visr = 0;
while(l <= r) {
res++;
while(visl <= bef and l <= r) {
visl += v[l];
l++;
}
L += visl;
if(visl <= bef or l > r) break;
bef = visl;
res++;
while(visr <= bef and l <= r) {
visr += v[r];
r--;
}
R += visr;
if(visr <= bef or l > r) break;
bef = visr;
visl = visr = 0;
}
cout << res << " " << L << " " << R << endl;
}
signed main() {
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
E. Special Elements
题目大意：
给出了数组 a = [ a 1 , a 2 , … , a n ] a=[a_1, a_2, \ldots, a_n] a=[a1,a2,…,an] ( 1 ≤ a i ≤ n 1 \le a_i \le n 1≤ai≤n )。它的元素 a i a_i ai 被称为特殊如果存在一对索引 l l l 和 r r r ( 1 ≤ l < r ≤ n 1 \le l < r \le n 1≤l<r≤n )使得 a i = a l + a l + 1 + … + a r a_i = a_l + a_{l+1} + \ldots + a_r ai=al+al+1+…+ar 。换句话说，如果一个元素可以表示为数组中两个或多个连续元素的和(无论它们是否特殊)，则该元素被称为特殊元素。
输出给定数组 a a a 中特殊元素的个数。
例如，如果 n = 9 n=9 n=9 和 a = [ 3 , 1 , 4 , 1 , 5 , 9 , 2 , 6 , 5 ] a=[3,1,4,1,5,9,2,6,5] a=[3,1,4,1,5,9,2,6,5] ，那么答案是 5 5 5 ：
- a 3 = 4 a_3=4 a3=4 是一个特殊元素，因为 a 3 = 4 = a 1 + a 2 = 3 + 1 a_3=4=a_1+a_2=3+1 a3=4=a1+a2=3+1 ；
- a 5 = 5 a_5=5 a5=5 是一个特殊元素，因为 a 5 = 5 = a 2 + a 3 = 1 + 4 a_5=5=a_2+a_3=1+4 a5=5=a2+a3=1+4 ；
- a 6 = 9 a_6=9 a6=9 是一个特殊元素，因为 a 6 = 9 = a 1 + a 2 + a 3 + a 4 = 3 + 1 + 4 + 1 a_6=9=a_1+a_2+a_3+a_4=3+1+4+1 a6=9=a1+a2+a3+a4=3+1+4+1 ；
- a 8 = 6 a_8=6 a8=6 是一个特殊元素，因为 a 8 = 6 = a 2 + a 3 + a 4 = 1 + 4 + 1 a_8=6=a_2+a_3+a_4=1+4+1 a8=6=a2+a3+a4=1+4+1 ；
- a 9 = 5 a_9=5 a9=5 是一个特殊元素，因为 a 9 = 5 = a 2 + a 3 = 1 + 4 a_9=5=a_2+a_3=1+4 a9=5=a2+a3=1+4 。
请注意，数组 a a a 中的某些元素可能是相等的——如果有几个元素是相等且特殊的，则应将所有元素都计算在答案中。
第一行包含一个整数 t t t ( 1 ≤ t ≤ 1000 1 \le t \le 1000 1≤t≤1000 )—输入中的测试用例的数量。然后是 t t t 测试用例。
每个测试用例用两行给出。第一行包含一个整数 n n n ( 1 ≤ n ≤ 8000 1 \le n \le 8000 1≤n≤8000 )——数组 a a a 的长度。第二行包含整数 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1,a2,…,an ( 1 ≤ a i ≤ n 1 \le a_i \le n 1≤ai≤n )。
保证输入中所有测试用例 n n n 的值之和不超过 8000 8000 8000 。
样例输入
5
9
3 1 4 1 5 9 2 6 5
3
1 1 2
5
1 1 1 1 1
8
8 7 6 5 4 3 2 1
1
1
样例输出
5
1
0
4
0
思路
由于数据范围很小，我们只需要统计 8000 8000 8000以内的结果。
创建 m p mp mp数组统计 a i < = 8000 a_i <= 8000 ai<=8000每个数出现的次数。
然后双重循环暴力寻找左右端点，如果和出现过就加上，注意加完之后和要清空，否则会重复计算。
代码
#include <bits/stdc++.h>
#define int long long
using namespace std;
int mp[8010];
void solve() {
memset(mp, 0, sizeof(mp));
int n; cin >> n;
vector<int> v(n + 1);
for(int i = 1; i <= n; i++) {
cin >> v[i];
mp[v[i]]++;
}
for(int i = 1; i <= n; i++)
v[i] += v[i - 1];
int res = 0;
for(int i = 1; i + 1 <= n; i++) {
for(int j = i + 1; j <= n; j++) {
if(v[j] - v[i - 1] <= 8000) {
res += mp[v[j] - v[i - 1]];
mp[v[j] - v[i - 1]] = 0;
} else {
break;
}
}
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
F. Binary String Reconstruction
题目描述：
对于某些二进制字符串 s s s (即每个字符 s i s_i si 是‘0’或‘1’)，将写入所有连续(相邻)字符对。
换句话说，写入长度为 2 2 2 的所有子字符串。对于每一对(长度为 2 2 2 的子串)，计算其中“1”(1)的个数。
给你三个数字：
- n 0 n_0 n0 -连续字符对(子字符串)的个数，其中1的个数等于 0 0 0 ；
- n 1 n_1 n1 -连续字符对(子字符串)的个数，其中1的个数等于 1 1 1 ；
- n 2 n_2 n2 -连续字符对(子字符串)的个数，其中1的个数等于 2 2 2 。
例如，对于字符串 s = s= s= “1110011110“，将写入以下子字符串：”11”,“11”,“10”,“00”,“01”,“11”,“11”,“11”,“11”,“11”,“10”。因此， n 0 = 1 n_0=1 n0=1 , n 1 = 3 n_1=3 n1=3 , n 2 = 5 n_2=5 n2=5 。
您的任务是从给定值 n 0 , n 1 , n 2 n_0, n_1, n_2 n0,n1,n2 中恢复任何合适的二进制字符串 s s s 。可以保证至少有一个数字 n 0 , n 1 , n 2 n_0, n_1, n_2 n0,n1,n2 大于 0 0 0 。此外，还保证存在解决方案。
题目大意：
三个正整数
a
,
b
,
c
a, b, c
a,b,c，构造一个01字符串
其中子串00的数量为
a
a
a，字串01 或10的数量为
b
b
b，字串11的数量为
c
c
c
例如 a = 2 , b = 3 , c = 4 a = 2, b = 3, c = 4 a=2,b=3,c=4
符合条件的字符串为： 0001111101 0001111101 0001111101
样例输入：
7
1 3 5
1 1 1
3 9 3
0 1 0
3 1 2
0 0 3
2 0 0
样例输出：
1110011110
0011
0110001100101011
10
0000111
1111
000
思路
分类讨论
-
b
=
=
0
b == 0
b==0，说明没有分界点，那么
a
,
c
a, c
a,c肯定有一个为
0
0
0，直接输出
a
+
1
a + 1
a+1个
0或者 c + 1 c + 1 c+1个1即可。 -
b
b
b大于
0
0
0的情况
- 先输出
a
+
1
a + 1
a+1个
0
0
0，再输出
c
+
1
c + 1
c+1个
1
1
1，由于前面一定包含一个交界点，最后再输出长度为
b
−
1
b - 1
b−1以
0
0
0开头的
01
01
01串
- 例：
a
=
4
,
b
=
5
,
c
=
2
a = 4, b = 5, c = 2
a=4,b=5,c=2，输出：000001110101
- 先输出 a + 1 a + 1 a+1个 0 0 0 ： 00000
- 再输出 c + 1 c + 1 c+1个 1 1 1：111
- 再输出长度为 b − 1 b - 1 b−1以 0 0 0开头的 01 01 01串：0101
- 例：
a
=
4
,
b
=
5
,
c
=
2
a = 4, b = 5, c = 2
a=4,b=5,c=2，输出：000001110101
- 先输出
a
+
1
a + 1
a+1个
0
0
0，再输出
c
+
1
c + 1
c+1个
1
1
1，由于前面一定包含一个交界点，最后再输出长度为
b
−
1
b - 1
b−1以
0
0
0开头的
01
01
01串
代码
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve() {
int a, b, c;
cin >> a >> b >> c;
if(b == 0) {
if(a != 0)
for(int i = 0; i <= a; i++)
cout << 0;
if(c != 0)
for(int i = 0; i <= c; i++)
cout << 1;
cout << endl;
return ;
}
for(int i = 0; i <= a; i++)
cout << "0";
for(int i = 0; i <= c; i++)
cout << "1";
for(int i = 2; i <= b; i++)
cout << i % 2;
cout << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
G. Special Permutation
题目描述：
长度为 n n n 的排列是一个数组 p = [ p 1 , p 2 , … , p n ] p=[p_1,p_2,\dots,p_n] p=[p1,p2,…,pn] ，其中包含从 1 1 1 到 n n n (包括)的所有整数，而且每个数字只出现一次。
例如， p = [ 3 , 1 , 4 , 2 , 5 ] p=[3,1,4,2,5] p=[3,1,4,2,5] 是长度为 5 5 5 的排列。
对于给定的数 n n n ( n ≥ 2 n \ge 2 n≥2 )，找到一个排列 p p p ，其中任意两个相邻元素的绝对差值(即差值的绝对值)在 2 2 2 和 4 4 4 之间，包括。
正式地，为每个 i i i ( 1 ≤ i < n 1 \le i < n 1≤i<n )找到 2 ≤ ∣ p i − p i + 1 ∣ ≤ 4 2 \le |p_i - p_{i+1}| \le 4 2≤∣pi−pi+1∣≤4 的排列 p p p 。
为给定的整数 n n n 打印任何这样的排列，或者确定它不存在。
题目大意：
给你一个整数 n n n，把 1 − n 1 - n 1−n里面的所有数字重新排列，要求最后的结果为相邻的每两个数字绝对值差在 2 − 4 2 - 4 2−4之间。
如果不能就输出 − 1 -1 −1
样例输入
6
10
2
4
6
7
13
样例输出
9 6 10 8 4 7 3 1 5 2
-1
3 1 4 2
5 3 6 2 4 1
5 1 3 6 2 4 7
13 9 7 11 8 4 1 3 5 2 6 10 12
思路
不难发现， n < = 3 n <= 3 n<=3的情况，无论怎么排都不可能，直接输出 − 1 -1 −1。
然后分两种情况
-
n
n
n为偶数，先从小到大输出所有偶数，再输出第二大的奇数跟最大的奇数，然后剩下的奇数从大到小输出。
- 例：
n
=
10
n = 10
n=10，排列为
2
4
6
8
10
7
9
5
3
1
2\ \ \ 4\ \ \ 6\ \ \ 8\ \ \ 10\ \ \ 7\ \ \ 9\ \ \ 5\ \ \ 3\ \ \ 1
2 4 6 8 10 7 9 5 3 1
- 先从小到大输出所有偶数： 2 4 6 8 10 2\ \ \ 4\ \ \ 6\ \ \ 8\ \ \ 10 2 4 6 8 10
- 再输出第二大的奇数跟最大的奇数： 7 9 7\ \ \ 9 7 9
- 然后剩下的奇数从大到小输出： 5 3 1 5\ \ \ 3\ \ \ 1 5 3 1
- 例：
n
=
10
n = 10
n=10，排列为
2
4
6
8
10
7
9
5
3
1
2\ \ \ 4\ \ \ 6\ \ \ 8\ \ \ 10\ \ \ 7\ \ \ 9\ \ \ 5\ \ \ 3\ \ \ 1
2 4 6 8 10 7 9 5 3 1
-
n
n
n为奇数，跟上面的方法类似，只不过是先输出所有奇数，再输出第二大的偶数跟最大的偶数，然后剩下的偶数从大到小输出。
- 例：
n
=
9
n = 9
n=9，排列为
1
3
5
7
9
6
8
4
2
1\ \ \ 3\ \ \ 5\ \ \ 7\ \ \ 9\ \ \ 6\ \ \ 8\ \ \ 4\ \ \ 2
1 3 5 7 9 6 8 4 2
- 先从小到大输出所有奇数： 1 3 5 7 9 1\ \ \ 3\ \ \ 5\ \ \ 7\ \ \ 9 1 3 5 7 9
- 再输出第二大的偶数跟最大的偶数： 6 8 6\ \ \ 8 6 8
- 然后剩下的偶数从大到小输出： 4 2 4\ \ \ 2 4 2
- 例：
n
=
9
n = 9
n=9，排列为
1
3
5
7
9
6
8
4
2
1\ \ \ 3\ \ \ 5\ \ \ 7\ \ \ 9\ \ \ 6\ \ \ 8\ \ \ 4\ \ \ 2
1 3 5 7 9 6 8 4 2
代码
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve() {
int n; cin >> n;
if(n <= 3) {
cout << - 1 << "\n";
return ;
}
if(n % 2 == 0) {
for(int i = 2; i <= n; i += 2)
cout << i << " ";
cout << n - 3 << " " << n - 1 << " ";
for(int i = n - 5; i >= 1; i -= 2)
cout << i << " ";
cout << "\n";
} else {
for(int i = 1; i <= n; i += 2)
cout << i << " ";
cout << n - 3 << " " << n - 1 << " ";
for(int i = n - 5; i >= 2; i -= 2)
cout << i << " ";
cout << "\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
cin >> t;
for(int i = 1; i <= t; i++)
solve();
return 0;
}
扫一扫
437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
