CodeForces-B

2022-10-09
B. Mathematical Circus

A new entertainment has appeared in Buryatia — a mathematical circus! The magician shows two numbers to the audience — nn and kk, where nn is even. Next, he takes all the integers from 11 to nn, and splits them all into pairs (a,b) (each integer must be in exactly one pair) so that for each pair the integer (a+k)⋅b is divisible by 4 (note that the order of the numbers in the pair matters), or reports that, unfortunately for viewers, such a split is impossible.
Burenka really likes such performances, so she asked her friend Tonya to be a magician, and also gave him the numbers nn and kk.
Tonya is a wolf, and as you know, wolves do not perform in the circus, even in a mathematical one. Therefore, he asks you to help him. Let him know if a suitable splitting into pairs is possible, and if possible, then tell it.
Input
The first line contains one integer tt (1≤t≤1041≤t≤104) — the number of test cases. The following is a description of the input data sets.
The single line of each test case contains two integers nn and k (2≤n≤2⋅105 , 0≤k≤109≤k≤109
n is even) — the number of integers and the number being added kk.
It is guaranteed that the sum of nn over all test cases does not exceed 2⋅1052⋅105.
Output
For each test case, first output the string “YES” if there is a split into pairs, and “NO” if there is none.
If there is a split, then in the following n2 lines output pairs of the split, in each line print 2 numbers — first the integer a, then the integer b.
Example
input
Copy
4
4 1
2 0
12 10
14 11
output
Copy
YES
1 2
3 4
NO
YES
3 4
7 8
11 12
2 1
6 5
10 9
YES
1 2
3 4
5 6
7 8
9 10
11 12
13 14
Note
In the first test case, splitting into pairs (1,2)(1,2) and (3,4)(3,4) is suitable, same as splitting into (1,4)(1,4) and (3,2)(3,2).
In the second test case, (1+0)⋅2=1⋅(2+0)=2(1+0)⋅2=1⋅(2+0)=2 is not divisible by 44, so there is no partition.
首先，谈论形如a*b=kn,k为设定的基数，n为n倍的式子时，应当考虑余数的可能而不是奇偶；寻找规律的时候注意考虑是不是讨论重复了，比如最开始，k%21与k%41。
其次，对于不可能的情况没有找到，
×-》k0，
√-》k%40
因为加上4的倍数对于原来的a来说没有任何改变，情况变成了1-n的双双组队之和要是4的倍数。而符合的只有n/4对，小于n/2对。
再次，观察猜想到组队是相邻两数就大大减少难度。

2022-10-10
B. Promo
The store sells nn items, the price of the ii-th item is pipi. The store’s management is going to hold a promotion: if a customer purchases at least xx items, yy cheapest of them are free.
The management has not yet decided on the exact values of xx and yy. Therefore, they ask you to process qq queries: for the given values of xx and yy, determine the maximum total value of items received for free, if a customer makes one purchase.
Note that all queries are independent; they don’t affect the store’s stock.
Input
The first line contains two integers nn and qq (1≤n,q≤2⋅1051≤n,q≤2⋅105) — the number of items in the store and the number of queries, respectively.
The second line contains nn integers p1,p2,…,pn (1≤pi≤1061≤pi≤106), where pi — the price of the ii-th item.
The following qq lines contain two integers xixi and yiyi each (1≤yi≤xi≤n1≤yi≤xi≤n) — the values of the parameters xx and yy in the ii-th query.
Output
For each query, print a single integer — the maximum total value of items received for free for one purchase.
Example
input
Copy
5 3 5 3 1 5 2 3 2 1 1 5 3
output
Copy
8 5 6
Note
In the first query, a customer can buy three items worth 5,3,5, the two cheapest of them are 3+5=8.
In the second query, a customer can buy two items worth 5 and 5, the cheapest of them is 5.
In the third query, a customer has to buy all the items to receive the three cheapest of them for free; their total price is 1+2+3=6
简单的前缀和，意识到是求长为x的最大段中前y个之和
！！错误是索引的计算
√：p[n-x+y]-p[n-x]
×：p[n-y-1]-p[n-x]

2022-10-11
B. Fun with Even Subarrays
You are given an array aa of nn elements. You can apply the following operation to it any number of times:
● Select some subarray from aa of even size 2k2k that begins at position l 1≤l≤l+2⋅k−1≤n, k≥1k≥1) and for each ii between 00 and k−1k−1 (inclusive), assign the value al+k+ial+k+i to al+i
For example, if a=[2,1,3,4,5,3] , then choose l=1 and k=2 , applying this operation the array will become a=[3,4,3,4,5,3]
Find the minimum number of operations (possibly zero) needed to make all the elements of the array equal.
Input
The input consists of multiple test cases. The first line contains a single integer tt (1≤t≤2⋅104 ) — the number of test cases. Description of the test cases follows.
The first line of each test case contains an integer nn (1≤n≤2⋅105 ) — the length of the array.
The second line of each test case consists of nn integers a1,a2,…,an ( 1≤ai≤n) — the elements of the array aa.
It is guaranteed that the sum of nn over all test cases does not exceed 2⋅105 .
Output
Print tt lines, each line containing the answer to the corresponding test case — the minimum number of operations needed to make equal all the elements of the array with the given operation.
Example
input
Copy
5 3 1 1 1 2 2 1 5 4 4 4 2 4 4 4 2 1 3 1 1
output
Copy
0 1 1 2 0
Note
In the first test, all elements are equal, therefore no operations are needed.
In the second test, you can apply one operation with k=1k=1 and l=1l=1, set a1:=a2a1:=a2, and the array becomes [1,1] with 1 operation.
In the third test, you can apply one operation with k=1k=1 and l=4l=4, set a4:=a5a4:=a5, and the array becomes [4,4,4,4,4].
In the fourth test, you can apply one operation with k=1k=1 and l=3l=3, set a3:=a4a3:=a4, and the array becomes [4,2,3,3], then you can apply another operation with k=2 and l=1, set a1:=a3, a2:=a4, and the array becomes [3,3,3,3].
In the fifth test, there is only one element, therefore no operations are needed.
💔不是自己写出来的
√：想到是2的幂次，改正了之前的2n次
💟贪心：
染色要变成什么呢？❎最多的，✅最后一个。因为执行变化的时候aN to ai；
怎么染色？处理同与不同。同则燃料+1，不同则燃料加倍（这样最佳，不用考虑里面有没有，至少染掉一个）
实现：
for (int i = n; i >= 1;)
{
if (a[i] == a[n])cplen++,i–;
else
{
cnt++;
// for (int k = 0; k < cplen; k++)
// {
// if (a[tid - k] != a[n])dif–;
// if (dif <= 0)break;
// }/优化/
cplen *= 2;
// if (dif <= 0)break;
i -= cplen / 2;
}

2022-10-12
B. Optimal Reduction
Consider an array a of nn positive integers.
You may perform the following operation:
● select two indices ll and rr (1≤l≤r≤n), then
● decrease all elements al,al+1,…,ar
Let’s call f(a)f(a) the minimum number of operations needed to change array aa into an array of nn zeros.
Determine if for all permutations†† bb of aa, f(a)≤f(b) is true.
†† An array b is a permutation of an array a if b consists of the elements of a in arbitrary order. For example, [4,2,3,4][4,2,3,4] is a permutation of [3,2,4,4][3,2,4,4] while [1,2,2] is not a permutation of [1,2,3]
Input
The first line contains a single integer tt (1≤t≤104) — the number of test cases.
The first line of each test case contains a single integer nn (1≤n≤105) — the length of the array aa.
The second line contains nn integers a1,a2,…,ana1,a2,…,an (1≤ai≤109) — description of the array aa.
It is guaranteed that the sum of nn over all test cases does not exceed 105.
Output
For each test case, print “YES” (without quotes) if for all permutations bb of aa, f(a)≤f(b) is true, and “NO” (without quotes) otherwise.
You can output “YES” and “NO” in any case (for example, strings “yEs”, “yes” and “Yes” will be recognized as a positive response).
Example
input
Copy
3
4
2 3 5 4
3
1 2 3
4
3 1 3 2
output
Copy
YES YES NO
Note
In the first test case, we can change all elements to 00 in 5 operations. It can be shown that no permutation of [2,3,5,4】 requires less than 55 operations to change all elements to 0.
In the third test case, we need 55 operations to change all elements to 00, while [2,3,3,1] only needs 3 operations.

💔也不是自己写的
❎考虑到应该是有峰值就最佳，但是没有认真思考为什么，以及是不是。三角形一样的操作数最佳
仅仅判断a[i]比两旁都大就认为YES是浅薄的，会有多峰的情况
✅最小操作肯定只有是全域单峰值才行
2022-10-13
B.最佳排列。
让我们定义n个整数1，2，…，n的排列p的值如下(排列是一个数组，其中从1到n的每个元素恰好出现一次)：
最初，整数变量x等于0；
如果x<p1，则将p1加到x(集合x=x+p1)，否则将0赋给x；
如果x<p2，则将p2加到x(集合x=x+p2)，否则将0赋给x；
…
如果x<pn，则将pn加到x(集合x=x+pn)，否则将0赋给x；
在这个过程结束时，排列的值是x。
例如，对于p=[4，5，1，2，3，6]，x的值变化如下：0，4，9，0，2，5，11，因此排列的值是11。
给你一个整数n。在所有大小为n的排列中找到一个大小为n的排列p，它的值可能最大。如果有几个这样的排列，你可以打印其中的任何一个。
输入
第一行包含一个整数t(1≤t≤97)–测试用例的数量。
每个测试用例的唯一行包含一个整数n(4≤n≤100)。
输出
对于每个测试用例，打印n个整数–大小为n的排列中具有最大可能值的大小为n的排列p。
示例。
输入复制。
3
4
5
6
输出复制。
2 1 3 4。
1 2 3 4 5。
4 5 1 2 3 6

💔
✅想到了最大的就是n+n-1,并且推出了正确的一个方法
❎没有构造对于奇数（没有意识到）的情况，对于清零的处理不好
通过计算不难发现x的最大值即为n+n-1,所以我们让排列的最后两个数为n-1,n，然后只需要令前面的数x=0即可，如果n是偶数的话只要两个数一组，前面的数比后面的大即可，比如n=6时，就是4 3 2 1 5 6，如果n是奇数的话，可以在n-1前面放上1 2 3这三个x=0的数，然后再按照n=偶数时的方式放前面的数，比如n=7的全排列为5 4 1 2 3 6 7

while(t–){
cin>>n;
if (n%2==0(
for(int i=n-2;i>=1;i–){
cout<<i<<" “;
}
cout<<n-1<<” “<<n;
else {
for(int i=n-2;i>=4;i++)
cout<<i<<” ";
cout<<"3 2 1 “<<n-1<<” "<<n;
}

    cout<<endl;
}

💟3 2 1比较特殊噢
2022-10-15
B.奇数交换排序。
每测试1秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
您将看到一个数组a1，a2，…。
、An.。
您可以在阵列上执行操作。
在每个操作中，您可以选择一个整数i(1≤i<n)，如果ai+ai+1是奇数，则交换数组的元素ai和ai+1。
确定是否可以使用此操作多次按非降序对其进行排序。
输入。
每个测试包含多个测试用例。
第一行包含单个整数t(1≤t≤105)–测试用例的数量。
测试用例的描述如下。
每个测试用例的第一行包含一个整数n(1≤n≤105)–数组的长度。
每个测试用例的第二行包含n个整数a1、a2、…。
，an(1≤ai≤109)-数组的元素。
可以保证所有测试用例上的n之和不超过2⋅105。
输出。
对于每个测试用例，根据您是否可以对给定的数组进行排序，打印“是”或“否”。
您可以在任何情况下打印每个字母(例如，“是”、“是”都将被视为肯定答案)。
示例。
输入复制。
4.
4.
1 6 31 14
2.
4 2
5.
2 9 6 7 10
3.
6 6 6
输出复制。
是
不是
不是
是
注意事项。
在第一个测试用例中，我们可以简单地交换31和14(31+14=45，这是奇数)，并获得非递减数组[1，6，14，31]。
在第二个测试用例中，我们可以对数组进行排序的唯一方法是交换4和2，但这是不可能的，因为它们的和4+2=6是偶数。
在第三个测试用例中，无法使数组不减。
在第四个测试用例中，数组已经是非递减的
💔
思维点在于，连续的奇、偶是无法交换的。那么若能交换则不能出现奇数偶数列上的逆序。否则一定会出现奇奇偶偶的情况
故，查询奇偶列的序列情况。
2022-10-17
B.避免局部最大值。
每测试2秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
您将看到一个大小为n的数组a。该数组中的每个元素都是一个介于1和109之间的整数。
您可以对此数组执行多个操作。
在操作过程中，可以用1到109之间的任意整数替换数组中的元素。
输出所需的最小操作数，以使结果数组不包含任何局部最大值，并在操作之后输出结果数组。
如果一个元素ai严格大于它的两个相邻元素(即ai>ai−1和ai>ai+1)，则它是局部极大值。
由于A1和AN各自只有一个邻居，因此它们永远不会是局部最大值。
输入。
每个测试包含多个测试用例。
第一行将包含单个整数t(1≤t≤10000)–测试用例的数量。
然后是t个测试用例。
每个测试用例的第一行包含一个整数n(2≤n≤2⋅105)–数组a的大小。
每个测试用例的第二行包含n个整数a1、a2、…。
，an(1≤ai≤109)，数组元素。
可以保证所有测试用例上的n之和不超过2⋅105。
输出。
对于每个测试用例，首先输出一行，该行包含单个整数m-所需操作的最小数量。
然后输出一个由n个整数组成的行–运算后得到的数组。
请注意，此数组应该与初始数组正好有m个元素不同。
如果有多个答案，请打印任何答案。
示例。
输入复制。
5.。
3.。
2 1 2。
4.。
1 2 3 1。
5.。
1 2 1 2 1。
9.。
%1%1%3%2%3%1%2%1。
9.。
2 1 3 1 3 1 3 1 3。
输出复制。
0
2 1 2
1
1 3 3 1
1
1 2 2 2 1。
2
%1%2%3%3%2%3%3%2%。
2
2 1 3 3 3 1 1 1 3
注意事项。
在第一个示例中，数组不包含局部最大值，因此我们不需要执行操作。
在第二个例子中，我们可以将a2改为3，然后数组没有局部最大值。
💖自己写滴
观察样例可知
最优的改变是要考虑a b c d e中的bd的，这样才能事倍功半；
修改的时候使c变为max(b,d)的值就好。
2022-10-18
B.排列值。
每测试2秒的时间限制。
每个测试的内存限制为512 MB。
输入标准输入。
输出标准输出。
给你一个整数n。你必须构造一个大小为n的排列。
置换是一个数组，其中从1到s(其中s是置换的大小)的每个整数恰好出现一次。
例如，[2，1，4，3]是大小为4的排列；[1，2，4，5，3]是大小为5的排列；[1，4，3]不是排列(没有整数2)，[2，1，3，1]不是排列(整数1出现两次)。
排列的子段是该排列的连续子序列。
例如，排列[2，1，4，3]有10个子段：[2]，[2，1]，[2，1，4]，[2，1，4，3]，[1]，[1，4]，[1，4，3]，[4，3]和[3]。
排列的值是它的子段的数目，这些子段也是排列。
例如，因为子段[2，1]、[1]和[2，1，4，3]是排列，所以[2，1，4，3]的值是3。
你必须构造一个大小为n的排列，在所有大小为n的排列中具有最小的可能值。
输入。
第一行包含一个整数t(1≤t≤48)–测试用例的数量。
然后，t线紧随其后。
其中的第i个测试用例包含一个表示第i个测试用例的整数n(3≤n≤50)。
输出。
对于每个测试用例，打印n个整数-大小为n且具有最小可能值的排列。
如果有多个这样的排列，则打印其中的任何一个。
示例。
输入复制。
2.。
5.。
6.。
输出复制。
1 4 3 5 2。
4 1 6 2 5 3。
注意事项。
在第一个例子中，排列[1，4，3，5，2]是可能的答案之一；它的值是2。
在第二个例子中，排列[4，1，6，2，5，3]是可能的答案之一；它的值是2。
B.排列值。
每测试2秒的时间限制。
每个测试的内存限制为512 MB。
输入标准输入。
输出标准输出。
给你一个整数n。你必须构造一个大小为n的排列。
置换是一个数组，其中从1到s(其中s是置换的大小)的每个整数恰好出现一次。
例如，[2，1，4，3]是大小为4的排列；[1，2，4，5，3]是大小为5的排列；[1，4，3]不是排列(没有整数2)，[2，1，3，1]不是排列(整数1出现两次)。
排列的子段是该排列的连续子序列。
例如，排列[2，1，4，3]有10个子段：[2]，[2，1]，[2，1，4]，[2，1，4，3]，[1]，[1，4]，[1，4，3]，[4，3]和[3]。
排列的值是它的子段的数目，这些子段也是排列。
例如，因为子段[2，1]、[1]和[2，1，4，3]是排列，所以[2，1，4，3]的值是3。
你必须构造一个大小为n的排列，在所有大小为n的排列中具有最小的可能值。
输入。
第一行包含一个整数t(1≤t≤48)–测试用例的数量。
然后，t线紧随其后。
其中的第i个测试用例包含一个表示第i个测试用例的整数n(3≤n≤50)。
输出。
对于每个测试用例，打印n个整数-大小为n且具有最小可能值的排列。
如果有多个这样的排列，则打印其中的任何一个。
示例。
输入复制。
2.。
5.。
6.。
输出复制。
1 4 3 5 2。
4 1 6 2 5 3。
注意事项。
在第一个例子中，排列[1，4，3，5，2]是可能的答案之一；它的值是2。
在第二个例子中，排列[4，1，6，2，5，3]是可能的答案之一；它的值是2。
💖greedy 800
题目要求输出的序列是使其连续子段符合1-n的规律尽量少，那么越小的排在大数后面就会越少构成
诀窍是1和2分居首尾即可
2022-10-19
B.有趣的和。
每测试1秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
您将看到一个包含n个整数的数组a。
您可以选择任何合适的子段al、al+1、…
，表示您可以选择任意两个整数1≤l≤r≤n，其中r−l+1<n。我们将给定子段的美感定义为以下表达式的值：
MAX(a1、a2、…al−1，Ar+1，Ar+2，…，an)−Min(a1，a2，…。al−1，Ar+1，Ar+2，…An)+max(al，ar)−Min(al，…AR)。
请在所有合适的细分中找到最美的部分。
输入。
第一行包含一个整数t(1≤t≤1000)–测试用例的数量。
然后按照每个测试用例的描述进行操作。
每个测试用例的第一行包含一个整数n(4≤n≤105)–数组的长度。
每个测试用例的第二行包含n个整数a1、a2、…。
，an(1≤ai≤109)-给定数组的元素。
可以保证所有测试用例上的n之和不超过105。
输出。
对于每个测试用例，打印一个整数-适当的子段的最大美感。
示例。
输入复制。
4.。
8个。
1 2 2 3 1 5 6 1。
5.。
1 2 3 100 200。
4.。
3 3 3。
6.。
7 8 3 1 1 8。
输出复制。
9.。
二百九十七。
0。
14.。
注意事项。
在第一个测试用例中，最优分段为l=7，r=8。该分段的美等于(6−1)+(5−1)=9。
在第二个测试用例中，最优分段为l=2，r=4。该分段的美等于(100−2)+(200−1)=297。
💖so easy
定义一个序列的“美丽值”为取出序列的有趣度与未被取走部分的有趣度之和
最大两个减去最小两个
因为要是美值最大，那么美值构成的max1,max2,min1,min2分别处于极端就好了；
2022-10-20
B.GCD阵列。
每测试2秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
考虑由范围[l，r]中的所有整数组成的数组a。
例如，如果l=3，r=7，则a=[3，4，5，6，7]。
在给定l、r和k的情况下，GCD(A)在执行以下运算至多k次后有可能大于1吗？
从a中选择2个数字。
从阵列中永久删除其中每个元素的一个匹配项。
将他们的产品重新插入到一个。
Gcd(B)表示b中整数的最大公约数(Gcd)。
输入。
输入的第一行包含单个整数t(1≤t≤105)–测试用例的数量。
测试用例的描述如下。
每个测试用例的输入由一行组成，其中包含3个非负整数l、r和k(1≤l≤r≤109，0≤k≤r−l)。
输出。
对于每个测试用例，如果可以通过执行至多k个操作使相应数组的GCD大于1，则打印“yes”，否则打印“no”(不区分大小写)。
示例。
输入复制。
9.。
1 1 0。
3 5 1。
13 13 0。
4 4 0。
3 7 4。
4 10 3。
2 4 0。
1 7 3。
1 5 3。
输出复制。
不是的。
不是的。
是。
是。
是。
是。
不是的。
不是的。
是。
注意事项。
对于第一个测试用例，a=[1]，所以答案是“no”，因为数组中唯一的元素是1。
对于第二个测试用例，数组为a=[3，4，5]，我们有1次操作。
在第一次运算之后，数组可以变为：[3，20]、[4，15]或[5，12]，所有这些数组的最大公约数都等于1，所以答案是“否”。
对于第三个测试用例，a=[13]，所以答案是“是”，因为数组中唯一的元素是13。
对于第四个测试用例，a=[4]，所以答案是“是”，因为数组中唯一的元素是4。
💔看npy的
思路：只要有偶数就说明有2这个约数，而是否会被k次消除就看k是否大于奇数的个数，这样就能成为一个偶数，而不用担心会不会偶奇不相约了

2022-10-21
B.基本粒子。
火星人正在积极地从事星际贸易。
奥林匹克城，这座以太空港闻名的火星城市，已经成为来自银河系各个角落的商品汇聚之地。
为了从遥远的行星运送更多的货物，火星人需要快速的宇宙飞船。
一组科学家进行实验，为新宇宙飞船制造快速发动机。
在本实验中，共有n个基本粒子，其中第i个基本粒子的类型为ai型。
表示粒子序列(a1、a2、…)的子段。
，an)作为序列(al，al+1，…。
，ar)对于某个左界l和右界r(1≤l≤r≤n)。
例如，l=2和r=4的序列(1 4 2 8 5 7)具有作为亚段的序列(4 2 8)。
如果两个子段中至少有一个边界不同，则认为这两个子段不同。
注意，子片段可以等同于序列，但仍然被认为是不同的。
例如，考虑序列(1111)及其两个子段：一个具有l=1和r=3，另一个具有l=2和r=4。这两个子段都等于(1111)，但仍然被认为是不同的，因为它们的左右边界不同。
科学家们希望进行一项反应，以获得两个相同长度的不同亚段。
表示该长度k。所得到的一对子段必须是协调的，即对于某些i(1≤i≤k)，对于这两个子段，第i位置上的粒子类型一定是相同的。
例如，对(1 7 3)和(4 7 8)是和谐的，因为两个子段在第二个位置上都有7。
这对(%1 2)和(%3%1%2)不协调。
和谐的子段越长，科学家设计快速发动机的机会就越大。
因此，他们让你计算由不同的子段组成的和谐对的最大可能长度。
输入。
第一行包含一个整数t(1≤t≤100)-测试用例的数量。
以下是对测试用例的描述。
第一行包含整数n(2≤n≤150000)-序列中基本粒子的数量。
第二行包含n个整数ai(1≤ai≤150000)-类型的基本粒子。
可以保证所有测试用例上的n之和不超过3⋅105。
输出。
对于每个测试，打印一个整数，由不同的子段组成的和声对的最大可能长度。
如果不存在这样的对，则改为打印−1。
示例。
输入复制。
4.。
7.。
3 1 5 2 1 3 4。
6.。
1 1 1。
6.。
1 4 2 8 5 7。
2.。
15 15。
输出复制。
4.。
5.。
-1。
1。
注意事项。
第一个测试用例如下图所示：
从图中可以看出，您可以选择(2 1 3 4)和(3 1 5 2)这两个子分段，它们是一对和谐的组合。
它们的长度等于4，所以答案是4。
在第二个测试用例中，您需要获取两个子段：一个是l=1和r=5，另一个是l=2和r=6。不难观察到，这两个段是一个和谐的对，即使它们都等于(1 1 1)，也被认为是不同的。
在第三个测试用例中，您无法生成和谐的配对，因此答案是−1。
💔1100 实现方式get
如何得到相同值之间的距离
▶struct 记录各值以及其下标，将其排序，按照值从小到大，其中再按照索引从小到大就可以得到了
然后计算max，序列长度的计算考虑一个就好，对于前一个，它的长度就是len=l-1+n-r+1
2022-10-22
输入三个数，可以选一个乘一个数后使这个数列是等差的
💔没有考虑这个：a+c = 2*b，要是c-a的绝对值是奇数那就不可以了
string solve(){

cin >> a >> b >> c ;

if((2 * b - c) % a == 0 && (2 * b - c) > 0) return "YES" ;
if((2 * b - a) % c == 0 && (2 * b - a) > 0) return "YES" ;
if((a + c) % 2 == 0 && ((a + c >> 1) % b == 0) && ((a + c >> 1) > 0)) return "YES" ;
return "NO" ;

}
2022-10-23
B.全球疾病问题。
每测试2秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
给定一个正整数n，找出三个不同的正整数a，b，c，使得a+b+c=n且gcd(a，b)=c，其中gcd(x，y)表示整数x和y的最大公约数(Gcd)。

输入。
输入由多个测试用例组成。第一行包含单个整数t(1≤t≤105)–测试用例的数量。测试用例的描述如下。

每个测试用例的第一行也是唯一一行包含单个整数n(10≤n≤109)。

输出。
对于每个测试用例，输出满足要求的三个不同的正整数a、b、c。如果有多个解决方案，您可以打印任何解决方案。我们可以证明答案总是存在的。

示例。
输入复制。
6.。
18。
63。
73。
91。
四百三十八。
122690412。
输出复制。
6 9 3。
21 39 3。
29 43 1。
49 35 7。
146 219 73。
28622 122661788 2。
注意事项。
在第一个测试用例中，6+9+3=18，GCD(6，9)=3。

在第二个测试用例中，21+39+3=63，GCD(21，39)=3。

在第三个测试用例中，29+43+1=73，GCD(29，43)=1。
💔问题就是质因数分解
思路是确定gcd(a,b）=1，找出（n-1）的两个质因数
然后若（n-1）/2是偶数，那么就找(n-1)/2前后距离为4的奇数（这一步有数学证明）
若是奇数，那么就找该奇数前后的奇偶数就好了
2022-10-24
B. Luntik和子序列
伦提克早晨出来散步，发现了一个长度为n的数组a。他计算了数组元素的和s (s=∑ni=1ai)。如果子序列中的数字之和等于s−1，则Luntik称该数组的子序列为接近满的。

Luntik真的很想知道数组a的几乎完整子序列的数量，但他需要回家，所以他让你解决这个问题!

如果可以通过删除几个(可能是0个或全部)元素从y中获得x，则序列x是序列y的子序列。

输入
第一行包含一个整数t(1≤t≤1000)——测试用例的数量。接下来的2行⋅t行包含测试用例的描述。每个测试用例的描述由两行组成。

每个测试用例的第一行包含一个整数n(1≤n≤60)——数组的长度。

第二行包含n个整数a1,a2，…，an(0≤ai≤109)——数组a的元素。

输出
对于每个测试用例，打印数组几乎完整的子序列的数量。
💖
本题只与0，1，的个数有关

特殊的，对于每个零选或不选就是pow(2,res)

2022-10-25
B.Verurteilung的王子。
我，费希尔，维鲁提隆王子，在命运的召唤下来到这片土地–哦，你也是来自另一个世界的旅行者吗？
很好，我允许你和我一起旅行。
菲舍尔说话的措辞很奇怪，这并不令人惊讶。
然而，这一次，连她的乌鸦朋友奥兹都无法解读她的表情！
也许你能帮我们理解这位年轻的公主在说什么？
您将看到一个由n个小写拉丁字母组成的字符串，也就是Fischl刚刚说出的单词。
您认为这个字符串的MEX可能会帮助您找到这条消息背后的含义。
字符串的MEX被定义为在输入中不显示为连续的子字符串的最短字符串。
如果存在多个字符串，则词典顺序上最小的字符串被视为MEX。
请注意，空子字符串不算有效的MEX。
当且仅当下列条件之一成立时，字符串a的词典顺序小于字符串b：
A是b的前缀，但却是≠b；
在a和b不同的第一个位置，字符串a的字母在字母表中的出现时间早于b中相应的字母。
如果a可以通过删除从开头开始的几个(可能是零个或全部)字符和从末尾删除几个(可能是零个或全部)字符从b获得，则字符串a是字符串b的子串。
找出弦的MEX是什么！
输入。
每个测试包含多个测试用例。
第一行包含测试用例的数量t(1≤t≤1000)。
测试用例的描述如下。
每个测试用例的第一行包含一个整数n(1≤n≤1000)–单词的长度。
每个测试用例的第二行包含一个由n个小写拉丁字母组成的字符串。
所有测试用例的n之和不会超过1000。
输出。
对于每个测试用例，在新行上输出字符串的MEX。
示例。
输入复制。
3
28
qaabzwsxedcrfvtgbyhnujmiklop
13
cleanairactbd
10
aannttoonn
输出复制。
ac
f
b：
给你一串字符串，然后按字典序求第一个没在这个字符串中出现的子串，如样例：qaabzwsxedcrfvtgbyhnujmiklop，a-z都出现了，aa出现了，ab出现了，ac没出现，答案就是ac。
给T，循环T，给n，然后给出长度为n的字符串，求找出在字符串中未出现的，最短的，最小字典序的子串
例如：给出串为
abc
其子串并按字典序排序为a,ab,abc,ac,b,bc,c,(有误请指正)
然后所求为未出现的，则符合要求**(最短)**的字串为 d
因为要求最短为前提，所以从单个字母开始，再到双位字母。。。。下去
做法
开个map进行存给出字串的所有子串
然后开一个bfs经行搜索，详情见代码

💔1200，果然好难
就是理解题意＆执行
暴力一点的方法就是将原串里面所有可能的串全加上，然后一个一个找在不在，如果这个字串它存在，就将它存进去，继续找。如果找到一个串它有一个子串最短且不在原串里面就输出。
找里面的连续的字符串，
DFS，

2022-10-26 732
B.水月和被盗的绳子。
水月亮有n根弦，每根弦的长度为m。
N是奇数。
当水月不在时，切尔诺试图将这n根弦配对在一起。
在制作了（n−1）/2对后，她发现只有一条线没有这对！
在愤怒中，她把每一根绳子都弄断了。
对于每一对，她选择了一些位置(最少1个，最多m个)，并在选定的位置交换了这对中两个字符串中的字母。
例如，如果m=6并且两个字符串“abcdef”和“xyzklm”在一对中，并且Cirno选择了位置2、3和6，则她将把‘b’换成‘y’，把‘c’换成‘z’，把‘f’换成‘m’。
得到的字符串将是“ayzdem”和“xbcklf”。
然后，Cirno偷走了没有配对的字符串，并以任意顺序洗牌了所有剩余的字符串。
水月亮发现剩下的n−1字符串完全混乱。
此外，她还记得最初的n个字符串。
她想知道哪根线被偷了，但她不擅长编程。
你能帮帮她吗？
输入。
这个问题是交互式的。
这意味着，您的解决方案将读取交互参与者提供的输入。
但交互参与者会在开始时给你完整的输入，之后，你应该打印答案。
所以你应该解决问题，就像你解决通常的、非交互的问题一样，因为你不会有任何交互过程。
您唯一不应该忘记的事情是在打印答案之后刷新输出缓冲区。
否则，您可能会得到“超过空闲限制”的判决。
有关刷新输出缓冲区的详细信息，请参阅交互式问题指南。
输入由多个测试用例组成。
第一行包含单个整数t(1≤t≤100)–测试用例的数量。
每个测试用例的第一行包含两个整数n，m(1≤n≤105，1≤m≤105)–分别是字符串的数量和每个字符串的长度。
接下来的n行每行都包含一个长度为m的字符串，描述最初的n个字符串。
所有字符串都由小写拉丁字母组成。
接下来的nCirno 1行每行都包含一个长度为m的字符串，描述−交换和重新排序后的字符串。
可以保证n是奇数，并且所有测试用例上的n⋅m之和不超过105。
黑客格式：
第一行应包含单个整数测试。之后，测试用例应遵循以下格式：
第一行应该包含两个整数n和m。
下面的n行应该包含n个长度为m的字符串，描述原始字符串。
以下n−12行应描述这些对。
它们应按以下顺序包含：第一个字符串的索引i(1≤i≤n)、第二个字符串的索引j(1≤j≤n，i≠j)、交换的位置数k(1≤k≤m)和交换的k个位置的列表(k个不同的索引，按任何顺序从1到m)。
最后一行应该包含从1到n的整数排列，描述字符串的重新排序方式。
字符串将按此排列中放置的索引的顺序放置，被盗的字符串索引将被忽略。
输出。
对于每个测试用例，使用偷来的字符串打印一行。
3
3 5
aaaaa
bbbbb
ccccc
aaaaa
bbbbb
3 4
aaaa
bbbb
cccc
aabb
bbaa
5 6
abcdef
uuuuuu
kekeke
ekekek
xyzklm
xbcklf
eueueu
ayzdem
ukukuk
output
ccccc
cccc
kekeke
Note
In the first test case, “aaaaa” and “bbbbb” exchanged all positions, and “ccccc” is the stolen string.
In the second test case, “aaaa” and “bbbb” exchanged two first positions, and “cccc” is the stolen string.
This is the first test in the hack format:

3
3 5
aaaaa
bbbbb
ccccc
1 2 5 1 2 3 4 5
2 1 3
3 4
aaaa
bbbb
cccc
1 2 2 1 2
2 1 3
5 6
abcdef
uuuuuu
kekeke
ekekek
xyzklm
1 5 3 2 3 6
2 4 3 2 4 6
5 4 1 2 3

💔比较简单，错误的地方在于应该对着索引删去

2022-10-27 726
B.坏男孩。
每测试1秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
莱利是一个非常坏的男孩，但同时，他也是一个溜溜球大师。
因此，他决定用他的溜溜球技巧来惹恼他的朋友安东。
安东的房间可以表示为n行m列的网格。
设(i，j)表示第i行第j列中的单元格。Anton当前站在他房间的位置(i，j)。
为了惹恼安东，莱利决定在房间的牢房里扔两个溜溜球(他们可以在同一个牢房里)。
因为安东不喜欢被扔在地上的溜溜球，他不得不把他们两个都捡起来，回到原来的位置。
安东行进的距离是通过两个溜溜球的位置并通过只行进到旁边的相邻单元格返回到(i，j)的最短路径。
也就是说，如果他在单元格(x，y)中，那么他可以在一步中到达单元格(x+1，y)、(x−1，y)、(x，y+1)和(x，y−1)(如果存在具有这些坐标的单元格)。
莱利在想，他应该把这两个溜溜球扔到哪里，这样安东的行程才能最大化。
但是因为他很忙，所以他让你告诉他。
输入。
第一行包含单个整数t(1≤t≤104)-测试用例的数量。
然后是t个测试用例。
每个测试用例的唯一行包含四个整数n，m，i，j(1≤n，m≤109，1≤i≤n，1≤j≤m)-房间的尺寸，以及Anton当前所在的单元格。
输出。
对于每个测试用例，打印四个整数x1，y1，x2，y2(1≤x1，x2≤n，1≤y1，y2≤m)–两个溜溜球应该被抛出的位置的坐标。
它们将在坐标(x1，y1)和(x2，y2)处投掷。
如果有多个答案，您可以打印任何答案。
示例。
输入复制。
7.。
2 3 1 1。
4 4 1 2。
3 5 2 2。
5 1 2 1。
3 1 3 1。
1 1 1。
1000000000 1000000000 1000000000 50。
输出复制。
1 2 2 3。
4 1 4 4。
3 1 1 5。
5 1 1 1。
1 1 2 1。
1 1 1。
50 1 1 1000000000。
注意事项。
以下是第一个测试用例的可视化。
💔很简单，但是就是因为举例没有搞清楚哇；
只要两个球在对角线就好了。再怎么走都会走完的。
2022-10-28 e115
B.小组。
N名学生参加了Berland Su程序设计课程的第一次会议(n为偶数)。
所有学生将被分成两组。
每组每周在五个工作日(星期一、星期二、星期三、星期四和星期五)中的一个工作日内每周上一节课，并且为小组选择的日子必须不同。
此外，两组学生的人数应该相同。
每个学生都填写了一份调查，告诉他们一周中哪些天对他们上课方便，哪些不方便。
你的任务是确定是否可以选择两个不同的工作日为小组安排课程(第一组将在第一个选定的日期上课，第二组将在第二个选定的日期上课)，并将学生分成两组，使小组大小相等，并且对每个学生来说，为他们的组选择上课日期是方便的。
输入。
第一行包含单个整数t(1≤t≤104)-测试用例的数量。
然后描述测试用例。
每个测试用例的第一行包含一个整数n(2≤n≤1000)-学生数量。
接下来的n行中的第i行包含5个整数，每个整数都是0或1。如果第j个整数是1，那么第i个学生可以在一周的第j天上课。
如果第j个整数为0，则第i个学生不能在第j天上课。
对输入的额外限制：对于每个学生来说，一周中至少有一天是方便的，所有测试用例的学生总数不超过105人。
输出。
对于每个测试用例，打印一个答案。
如果可以将学生分成两个大小相等的小组，并为每个小组选择不同的日期，以便每个学生都可以在他们所在小组的选定日期上课，请打印“YES”(不带引号)。
否则，打印“no”(不带引号)。
示例。
输入复制。
2.。
4.。
1 0 0 1 0。
0 1 0 0 1。
0 0 0 1 0。
0 1 0 1 0。
2.。
0 0 0 1 0。
0 0 0 1 0。
输出复制。
是。
不是的。
注意事项。
在第一个测试用例中，有一种满足所有约束的方法。
例如，第一组可以由第一和第三名学生组成，他们将在周四(第四天)上课；第二组可以由第二和第四名学生组成，他们将在周二(第二天)上课。
在第二个测试案例中，不可能将学生分组，以便他们在不同的日期上课。
💔本来想用字符串找的。没实现成功；
暴力枚举
2022-10-29
B.Divan和一个新项目。
“Divan‘s沙发”公司正计划在一条坐标线上建造n+1个不同的建筑，以便：
每栋建筑的坐标是一个整数；
没有两座建筑矗立在同一点上。
让xi作为第i栋建筑的坐标。
从i号楼到j号楼，Divan花费|xi−xj|分钟，其中|y|是y的绝对值。
Divan要建造的所有建筑都可以从0到n编号。这位商人将住在0号楼，也就是“Divan的沙发”的新总部。
在建成后的头十年里，戴文将参观第i号建筑AI次，每次花费2⋅|x0−xi|分钟步行。
Divan让你选择所有n+1座建筑的坐标，这样在接下来的十年里，商人花在走路上的时间就会尽可能少。
输入。
每个测试都包含几个测试用例。
第一行包含一个整数t(1≤t≤103)–测试用例的数量。
每个案例的第一行都包含一个整数n(1≤n≤2⋅105)–除了总部之外，“Divan的沙发”要建造的建筑物的数量。
第二行包含序列a1、a2、…。
，An(0≤ai≤106)，其中ai是访问第i栋建筑的次数。
可以保证所有测试用例上的n之和不超过2⋅105。
输出。
对于每个测试用例，在第一行打印数字T-Divan将花费的最小步行时间。
在第二行打印序列x0、x1、…。
，xn的n+1个整数，其中xi(−106≤xi≤106)是第i栋建筑的选定坐标。
可以证明，存在坐标不超过106的最优解。
如果有多个答案，请打印其中任何一个。
示例。
输入复制。
4.。
3.。
1 2 3。
5.。
3 8 10 6 1。
5.。
1 1 1。
1。
0。
输出复制。
14.。
2 4 1 3。
78。
1-1 0 2 3 4。
18。
3 6 1 5 2 4。
0。
1 2。
注意事项。
让我们看一下第一个例子。
Divan将访问第一个建筑a1=1次，第二个a2=2次，第三个a3=3次。
则最佳解决方案之一将如下所示：
总部位于X0=2；
X1=4：Divan将花费2⋅|x0−x1|⋅a1=2⋅|2−4|⋅1=4分钟步行到第一栋建筑；
X2=1：Divan将花费2⋅|x0−x2|⋅a2=2⋅|2−1|⋅2=4分钟步行到第二栋建筑；
X3=3：Divan将花费2⋅|x0−x3|⋅A3=2⋅|2−3|⋅3=6分钟步行到第三栋建筑。
总而言之，Divan将花费4+4+6=14分钟。
可以看出，要让商人花更少的时间来安排建筑物是不可能的。
其中，x=[1，3，2，0]，x=[−5，−3，−6，−4]也是第一个例子的正确答案。
🤍思路对的，没实现
以最大的次数为一点，x0就修在旁边；
like:
1 2 3 4 0 4 3 2 1
2022-10-30
B.数组重新排序。
您将看到一个由n个整数组成的数组a。
如果1≤i<j≤n和gcd(ai，2aj)>1(其中gcd(x，y)是x和y的最大公约数)，我们称一对指数i，j为好的。
如果可以以任意方式对数组a重新排序，则找出良好索引对的最大数量。
输入。
第一行包含单个整数t(1≤t≤1000)-测试用例的数量。
测试用例的第一行包含单个整数n(2≤n≤2000)-数组中的元素数。
测试用例的第二行包含n个整数a1，a2，…。
，An(1≤ai≤105)。
可以保证所有测试用例的n之和不超过2000。
输出。
对于每个测试用例，输出一个整数–如果可以以任意方式对数组a重新排序，则为良好索引对的最大数量。
示例。
输入复制。
3
4
3 6 5 3
2
1 7
5
1 4 2 4 1
输出复制。
4.
0
9.
注意事项。
在第一个例子中，数组元素可以按如下方式重新排列：[6，3，5，3]
在第三个例子中，数组元素可以按如下方式重新排列：[4，4，2，1，1]
💔没有实现成功
bool cmp(int a,int b){
return (a&1)>(b&1);
}
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=1e5+10;
int t,n,ans,cnt,res,a[N],b[N],c[N];
int gcd(int a,int b){
return b == 0 ? a : gcd(b,a % b);
}
bool cmp(int a,int b){
return (a&1)<(b&1);
}
int main(){
cin>>t;
while(t–){
cin>>n;
ans=0;
for(int i=0;i<n;i++)cin>>a[i];
sort(a,a+n,cmp);

    for(int i=0;i<n;i++){
        // cout << a[i] << " ";
        if(a[i]%2==1){
            for(int j=i+1;j<n;j++){
                // if(a[j]%2==0)continue;
                // cout << a[i] << " " << a[j] << " " << __gcd(a[i], a[j] << 1) << "\n";
                if(gcd(a[i],2*a[j]) !=1 )ans++;
            }
        }
        else ans+=n-i-1;
    }
    cout<<ans<<endl;
}
return 0;

}

2022-10-31 732
B.我讨厌1111。

你得到一个整数x。你能通过把11,111,1111,11111的一些数字相加得到x吗，…。
？
(您可以使用其中的任意数字任意次数)。
例如,。
33=11+11+11。
144=111+11+11+11。
输入。
第一行输入包含单个整数t(1≤t≤10000)-测试用例的数量。
每个测试用例的第一行也是唯一一行包含一个整数x(1≤x≤109)–这是您必须计算的数字。
输出。
对于每个测试用例，您应该输出单个字符串。
如果可以生成x，则输出“yes”(不带引号)。
否则，输出“no”。
您可以打印每个字母的“是”和“否”的任何大小写(大写或小写)。
示例。
输入复制。
3.。
33。
144。
69。
输出复制。
是。
是。
不是的。
注意事项。
声明中提出了制作33和144的方法。
可以证明，我们不能以这种方式呈现69。
💔完全不知道也
11和111可以构造1111，11111…,
我们通过找规律可以发现，除了11和111，剩下的1111，11111…都可以通过11和111来构造出来，所以我们这题的关键就是求x是否能被11和111构造出来。
x=11a+111b。 a>=0,b>=0;
而b又可以转换成 b=c11+d ，d<11.
所以x=11（a+111c）+111d，d<11
我们可以通过枚举d的值，来判断x-111d是不是11的倍数，最多也只会枚举11次，所以是可以过的。
while(t–){
bool f=0;
cin>>n;int i=0;
for(;i111<=n;i++){
if((n-i*111)%11==0){
f=1;
break;
}
}
if(f)cout<<“YES\n”;
else cout<<“NO\n”;
}
}
2022-11-01
B.纳斯提亚和一个好的阵列。
纳西娅收到了一组n个正整数作为礼物。
她称这样的数组为好数组，使得对于所有i(2≤i≤n)发生gcd(ai−1，ai)=1，其中gcd(u，v)表示整数u和v的最大公约数(Gcd)。
您可以执行该操作：选择两个不同的索引i，j(1≤i，j≤n，i≠j)和两个整数x，y(1≤x，y≤2⋅109)，使得MIN(ai，aj)=MIN(x，y)。
然后将ai更改为x，将Aj更改为y。
女孩要求您使用最多n次操作来使数组变得很好。
可以证明，这永远是可能的。
输入。
第一行包含单个整数t(1≤t≤10000)-测试用例的数量。
每个测试用例的第一行包含一个整数n(1≤n≤105)–数组的长度。
每个测试用例的第二行包含n个整数a1、a2、…。
，an(1≤ai≤109)-纳斯蒂亚作为礼物收到的数组。
保证一次测试中n的总和不超过2⋅105。
输出。
对于每个测试用例，打印一个整数k(0，≤，k，≤，n)-操作的数量。
您不需要最小化这个数字。
在接下来的k行中的每一行中，打印4个整数i，j，x，y(1≤i≠j≤n，1≤x，y≤2min 109)，使得⋅(ai，aj)=min(x，y)-以这种方式，您用x替换ai，用y替换aj。
如果有多个答案，请打印任何答案。
示例。
输入复制。
2.。
5.。
9 6 3 11 15。
3.。
7 5 13。
输出复制。
2.。
1 5 11 9。
2 5 7 6。
0。
注意事项。
考虑第一个测试用例。
最初a=[9，6，3，11，15]。
在第一个操作中，将a1替换为11，将a5替换为9。它是有效的，因为min(a1，a5)=min(11，9)=9。
此后a=[11，6，3，11，9]。
在第二个运算中，用7替换a2，用6替换a5。它是有效的，因为min(a2，a5)=min(7，6)=6。
在此之后，a=[11，7，3，11，6]-一个良好的数组。
在第二个测试用例中，初始数组已经很好了。
💔哭哭
有一个重要的规律就是数列中最小的数肯定没有被取代，那么就从最小的数开始，一步一步将周围的数变成他们的索引值（Min最开始肯定也是啦，然后x,y也是随便找地话固定minindex和min就好啦
这样gcd(a,a-1)肯定就是1啦

2022-11-02 721
B1.。
回文游戏(简易版)。
简单版本和难版本之间的唯一区别是，简单版本中的给定字符串s最初是回文，对于难版本，这一条件并不总是成立的。
回文是从左到右和从右到左读相同的字符串。
例如，“101101”是回文，而“0101”不是。
爱丽丝和鲍勃在一个长度为n的字符串s(在这个版本中最初是回文)上玩游戏，该字符串由字符‘0’和‘1’组成。
两名选手轮流上场，爱丽丝先上场。
在每个回合中，玩家可以执行以下操作之一：
选择任意i(1≤i≤n)，其中s[i]=‘0’，并将s[i]改为‘1’。
付1美元。
反转整个字符串，支付0美元。
只有当字符串当前不是回文，并且上一次操作不是反向操作时，才允许此操作。
也就是说，如果Alice反转了弦，那么Bob在下一步就不能反转了，反之亦然。
颠倒字符串意味着将其字母从最后一个重新排序到第一个。
例如，颠倒后的“01001”变成“10010”。
当字符串的每个字符都变成‘1’时，游戏结束。
在这一点上花费最少美元的玩家赢得了比赛，如果双方花费相等的话就是平局。
如果双方都打得最好，输出爱丽丝赢了，鲍勃赢了，还是平局。
输入。
第一行包含单个整数t(1≤t≤103)。
然后是t个测试用例。
每个测试用例的第一行包含单个整数n(1≤n≤103)。
每个测试用例的第二行包含长度为n的字符串s，该字符串由字符‘0’和‘1’组成。
可以保证字符串s是回文，并且至少包含一个‘0’。
请注意，测试用例上的n个数之和没有限制。
输出。
对于每个测试用例，在新行中打印一个单词：
“爱丽丝”，如果爱丽丝会赢这场比赛。
“鲍勃”，如果鲍勃会赢这场比赛。
“抽签”，如果比赛以平局结束。
示例。
输入复制。
2.。
4.。
1001。
1。
0。
输出复制。
鲍伯。
鲍伯。
注意事项。
在该示例的第一个测试用例中，
在第一步中，Alice必须执行第一步操作，因为字符串当前是回文。
在第二步棋中，鲍勃把弦颠倒过来.。
在第三步中，Alice必须再次执行第一步操作。
字符串的所有字符都是“%1”，游戏结束。
爱丽丝花了2美元，而鲍勃只花了0美元。
因此，鲍勃总是赢。
💔
关键是0的个数是偶数

2022-11-03
B.蛋糕是个谎言。
有一个n×m的网格。
您正站在单元格(1，1)，而您的目标是在单元格(n，m)结束。
您可以向右或向下移动到相邻单元格。
换句话说，假设您站在单元格(x，y)。
你可以：
向右移动到单元格(x，y+1)-它的成本是x Burles；
向下移动到单元格(x+1，y)-它的成本是y Burles。
你能用k Burles准确到达(n，m)号吗？
输入。
第一行包含单个整数t(1≤t≤100)-测试用例的数量。
每个测试用例的第一行(也是唯一行)包含三个整数n、m和k(1≤n，m≤100；0≤k≤104)-网格的大小和您需要花费的确切金额。
输出。
对于每个测试用例，如果您可以使用k Burles精确到达单元格(n，m)，则打印YES。
否则，打印编号。
您可以按任意大小写打印每个字母(例如，字符串YES、YES、YES和YES都被视为肯定答案)。
示例。
输入复制。
6.。
1 1 0。
2 2 2。
2 2 3。
2 2 4。
1 4 3。
100100 10000。
输出复制。
是。
不是的。
是。
不是的。
是。
不是的。
注意事项。
在第一个测试用例中，您已经在最后一个单元格中，所以您花费了0个Burles。
在第二、第三和第四个测试用例中，从(1，1)到(2，2)有两条路径：(1，1)→(1，2)→(2，2)或(1，1)→(2，1)→(2，2)。
两者的价格都是1+2=3伯尔斯，所以这是你唯一能花的钱。
在第五个测试用例中，只有一条路从(1，1)到(1，4)，它的成本是1+1+1=3 Burles。
💔没有发现其对于每一个n,m，花费是一样的
因为起点是（1，1）所以对于
花费是n*m-1

2022-11-04
B.GCD长度。
你会得到三个整数a、b和c。
找出两个正整数x和y(x>0，y>0)，使得：
不带前导零的x的十进制表示法由数字组成；
不带前导零的y的十进制表示法由b位组成；
不带前导零的gcd(x，y)的十进制表示由c位组成。
GCD(x，y)表示整数x和y的最大公约数(GCD)。
输出x和y。如果有多个答案，则输出其中任何一个。
输入。
第一行包含单个整数t(1≤t≤285)-测试用例的数量。
接下来的t行中的每一行都包含三个整数a、b和c(1≤a，b≤9，1≤c≤min(a，b))–所需的数字长度。
证明了在给定约束条件下，所有测试用例的解都是存在的。
对输入的附加约束：所有测试用例都是不同的。
输出。
对于每个测试用例，打印两个正整数-x和y(x>0，y>0)，使得。
不带前导零的x的十进制表示法由数字组成；
不带前导零的y的十进制表示法由b位组成；
不带前导零的gcd(x，y)的十进制表示由c位组成。
示例。
输入复制。
4.。
2 3 1。
2 2 2。
6 6 2。
1 1 1。
输出复制。
11 492。
13 26。
140133 160776。
1 1。
注意事项。
在该示例中：
GCD(11,492)=1。
GCD(13，26)=13。
GCD(140133,160776)=21。
GCD(1，1)=1
💖推断对啦
#include<bits/stdc++.h>
using namespace std;
int t,a,c,b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>t;
while(t–){
cin>>a>>b>>c;
int te=pow(10,a)/10;
int tm=pow(10,b)/10;
int tp=pow(10,c)/10;
cout<<te+tp<<" "<<tm<<endl;
}
}

这个位数的关键就是想到用10来堆砌.然后c就来截断

2022-11-05
B.排列排序。
每测试2秒的时间限制。
每个测试的内存限制为256 MB。
输入标准输入。
输出标准输出。
您将看到一个由n个数字1、2、…、n组成的排列a(排列是一个数组，其中从1到n的每个元素恰好出现一次)。
您可以执行以下操作：选择的某个子数组(连续的子段)，并以任何您想要的方式重新排列其中的元素。
但此操作不能应用于整个数组。
例如，如果a=[2，1，4，5，3]并且我们想对子数组a2，4应用该运算，则在该运算之后，该数组可以变为a=[2，5，1，4，3]或，例如，a=[2，1，5，4，3]。
您的任务是计算上述操作的最小数量，以便按升序对排列a进行排序。
输入。
第一行包含单个整数t(1≤t≤2000)-测试用例的数量。
测试用例的第一行包含单个整数n(3≤n≤50)–排列中的元素数量。
测试用例的第二行包含从1到n的n个不同的整数-给定的排列a。
输出。
对于每个测试用例，输出单个整数–上面描述的按升序对数组a进行排序的最小操作数。
示例。
输入复制。
3.。
4.。
1 3 2 4。
3.。
1 2 3。
5.。
2 1 4 5 3。
输出复制。
1。
0。
2.。
注意事项。
在解释中，a[i，j]定义了a的子数组，它从第i个元素开始，以第j个元素结束。
在该示例的第一个测试用例中，您可以选择子数组a[2，3]并交换其中的元素。
在该示例的第二个测试用例中，排列已经排序，因此不需要应用任何操作。
在该示例的第三个测试用例中，您可以选择子数组a[3，5]并重新排序其中的元素，使a变为[2，1，3，4，5]，然后选择子数组a[1，2]并交换其中的元素，使a变为[1，2，3，4，5]。
💖,只和1，n，的位置和整体顺序有关
0：已经升序
1：1、n任意之一在其位
2：其他
3：完全倒序

2022-11-06
B.Sifid和奇异子序列。

序列(b1，b2，…。
，bk)，如果它的任何一对元素之间的绝对差大于或等于序列中的最大元素，则称为奇异。
从形式上讲，如果对于每个有1个≤i<j≤k的(i，j)对，我们有|ai−aj|≥max，其中max是序列中最大的元素。
特别是，任何长度不超过1的序列都是奇怪的。
例如，序列(−2021，−1，−1，−1)和(−1，0，1)很奇怪，但(3，0，1)不奇怪，因为|0−1|<3。
SIFID具有n个整数的数组a。
Sifid喜欢任何大的东西，所以在a的所有奇怪的子序列中，他想找出最长的一个的长度。
你能帮帮他吗？
如果c可以通过删除几个(可能是零个或全部)元素从d获得，则序列c是数组d的子序列。
输入。
第一行包含一个整数t(1≤t≤104)–测试用例的数量。
测试用例的描述如下。
每个测试用例的第一行包含一个整数n(1≤n≤105)–数组a的长度。
每个测试用例的第二行包含n个整数a1、a2、…。
，an(−109≤ai≤109)-数组a的元素。
可以保证所有测试用例上的n之和不超过105。
输出。
对于每个测试用例输出一个整数–最长的奇异子序列的长度。
示例。
输入复制。
6.。
4.。
-1-2 0 0。
7.。
-3 4-2 0-4 6 1。
5.。
0 5-3 2-5。
3.。
2 3 1。
4.。
-3 0 2 0。
6.。
-3-2-1 1 1。
输出复制。
4.。
5.。
4.。
1。
3.。
4.。
注意事项。
在第一个测试用例中，最长的奇异子序列之一是(a1，a2，a3，a4)。
在第二个测试用例中，最长的奇异子序列之一是(a1，a3，a4，a5，a7)。
在第三个测试用例中，最长的奇异子序列之一是(a1，a3，a4，a5)。
在第四个测试用例中，最长的奇异子序列之一是(A2)。
在第五个测试用例中，最长的奇异子序列之一是(a1，a2，a4)。
💔对于正数的处理不好
首先，肯定不用删除负数，这样既可以扩大差的绝对值又可以缩小原数值
其次，最多有一个整数，对于任意两个正数，之差绝对小于max正
2022-11-07
B.和0，Sum Big。
宝宝巴达维的第一句话是“和0和大”，于是他决定解决下面的问题。
给定两个整数n和k，计算长度为n的数组的数目，以使：
其所有元素均为0到2k−1(含)之间的整数；
其所有元素的逐位AND为0；
它的元素之和尽可能地大。
由于答案可能非常大，因此打印其除以109+7时的余数。
输入。
第一行包含一个整数t(1≤t≤10)–您需要解决的测试用例的数量。
每个测试用例由一行包含两个整数n和k(1≤n≤105，1≤k≤20)组成。
输出。
对于每个测试用例，打印满足条件的数组数量。
由于答案可能非常大，因此打印其除以109+7时的余数。
示例。
输入复制。
2.。
2 2。
100000 20。
输出复制。
4.。
226732710。
注意事项。
在第一个示例中，4个阵列是：
[3，0]，
[0，3]，
[1，2]，
[2，
将数看成二进制，每一个数最大有k位，要找n个数满足要求，那么在每一个数的某一位上有一个0就好，一共找k次
Cn1*k—>快速幂解得即可

2022-11-08
B.可悲的排列。
我在想，这场倾盆大雨。
永远向往它的不屑吗？
精神的排泄物。
你会得到一个正整数n。
找出长度为n的任意排列p，使得和lcm(1，p1)+lcm(2，p2)+…。
+lcm(n，pn)尽可能大。
这里，LCM(x，y)表示整数x和y的最小公倍数(LCM)。
排列是由从1到n的n个不同整数按任意顺序组成的数组。
例如，[2，3，1，5，4]是排列，但[1，2，2]不是排列(2在数组中出现两次)，[1，3，4]也不是排列(n=3，但数组中有4)。
输入。
每个测试包含多个测试用例。
第一行包含测试用例的数量t(1≤t≤1000)。
测试用例的描述如下。
每个测试用例的唯一行包含单个整数n(1≤n≤105)。
可以保证所有测试用例上的n之和不超过105。
输出。
对于每个测试用例，打印n个整数p1、p2、…。
，pn-最大可能值为lcm(1，p1)+lcm(2，p2)+…的排列。
+lcm(n，pn)。
如果有多个答案，请打印其中任何一个。
示例。
输入复制。
2.。
1。
2.。
输出复制。
1。
2 1。
注意事项。
对于n=1，只有一个排列，所以答案是[1]。
对于n=2，有两种排列：
[1，2]-和为LCM(1，1)+LCM(2，2)=1+2=3。
[2，1]-和为LCM(1，2)+LCM(2，1)=2+2=4。
💖
lcm(a,b)=a*b/gcd(a,b)
使1-n的lcm(i,pi）之和最大，那么gcd为1，则奇偶数互换即可

2022-11-09
B.ugu。
二进制字符串是只由字符0和1组成的字符串。您将获得一个二进制字符串s1s2…。
序列号。
必须使该字符串在最少的操作次数中不减。
换句话说，每个字符都不应小于前一个字符。
在一次操作中，您可以执行以下操作：
在字符串中选择任意索引1≤i≤n；
对于所有j≥i，将第j个位置的值更改为相反的值，即，如果sj=1，则使sj=0，反之亦然。
使字符串非递减所需的最少操作次数是多少？
输入。
每个测试由多个测试用例组成。
第一行包含一个整数t(1≤t≤104)–测试用例的数量。
测试用例的描述如下。
每个测试的第一行用一个整数n(1≤n≤105)表示字符串的长度。
每个测试用例的第二行包含长度为n的二进制字符串s。
可以保证所有测试用例上的n之和不超过2⋅105。
输出。
对于每个测试用例，输出一个整数–使字符串非递减所需的最小操作数。
示例。
输入复制。
8个。
1。
1。
2.。
10。
3.。
101。
4.。
1100。
5.。
11001。
6.。
100010。
10。
0000110000。
7.。
0110010。
输出复制。
0。
1。
2.。
1。
2.。
3.。
1。
5.。
注意事项。
在第一个测试用例中，字符串已经是非递减的。
在第二个测试用例中，您可以选择i=1，然后选择s=01。
在第三个测试用例中，您可以选择i=1并获得s=010，然后选择i=2。结果，我们得到s=001，即一个非递减字符串。
在第六个测试用例中，您可以在第一次迭代时选择i=5，得到s=100001。
然后选择i=2，然后选择s=111110。
然后我们选择i=1，得到非递减字符串s=000001。
💔
模拟置换
本质是10或者01组成的串
void solve() {
int n;
scanf(“%d %s”, &n, str + 1);
memset(s, 0, sizeof(s));
for (int i = n; i; i–) {
s[i] = s[i + 1] + (str[i] & 1); // 求后缀1个个数
}

int ret = 0;
for (int i = 1, t = 0; i <= n; i++) {    // t代表置换的累加次数
    if (!t && s[i] == n - i + 1) break;    // 如果置换了偶数次，并且[i, n]中全为1，那么就不用再置换了
    if (t && !s[i]) break;                // 如果置换了奇数次，并且[i, n]中全为0（等价于置换后全为1），也不用置换了
    if ((str[i] & 1) ^ t) ret++, t ^= 1;    // 遇到1就置换
}

printf("%d\n", ret);

}

2022-11-10 832
B.禁止禁令。
你会得到一个整数n。
让我们将s(N)定义为连接n次的字符串“ban”。
例如，s(1)=“BAN”，s(3)=“BANBANBAN”。
请注意，字符串的长度s(N)等于3n。
考虑s(N)。
您可以对s(N)执行以下操作任意次(可能为零)：
选择任意两个不同的索引i和j(1≤i，j≤3n，i≠j)。
然后，交换s(N)i和s(N)j。
您希望字符串“ban”不作为子序列出现在s(N)中。
要做到这一点，你需要做的最小手术次数是多少？
另外，找出这样一个最短的操作序列。
如果a可以通过删除几个(可能是零个或全部)字符从b获得，则字符串a是字符串b的子序列。
输入。
输入由多个测试用例组成。
第一行包含单个整数t(1≤t≤100)–测试用例的数量。
测试用例的描述如下。
每个测试用例的唯一行包含单个整数n(1≤n≤100)。
输出。
对于每个测试用例，在第一行输出m(0≤m≤105)-所需的最小操作数。
可以保证，在问题的约束下，在最多105次操作中总是可以实现目标的。
然后，输出m行。
这些行中的第k行应该包含两个整数ik，jk(1≤ik，jk≤3n，ik≠jk)，表示您希望在第k个操作中交换索引为ik和jk的字符。
在所有m次操作之后，“BAN”不能作为子序列出现在s(N)中。
如果有多个可能的答案，则输出任何答案。
示例。
输入复制。
2.。
1。
2.。
输出复制。
1。
1 2。
1。
2 6。
注意事项。
在第一个测试用例s(1)=“BAN”中，我们可以交换s(1)1和s(1)2，将s(1)转换为不包含“BAN”作为子序列的“ABN”。
在第二个测试用例s(2)=“BANBAN”中，我们可以交换s(2)2和s(2)6，将s(2)转换为“BNNBAA”，它不包含“BAN”作为子序列。
💖💐奇偶情况找
对于n个ban，交换a,n,使n在a的前面，
if(n%2==0){
cout<<n/2<<endl;
int j=0;
for(int i=0;i<n/2;i++){
cout<<2+j<<" "<<3*n-j<<endl;
j+=3;
}
}
2022-11-11 829
B.凯文和排列。
在他的生日上，凯文收到了一组两两不同的数字1，2，3，…。
，n作为礼物。
他将以一种方式排列这些数字，使两个连续数字之间的最小绝对差成为可能。
更正式地说，如果他按顺序p1、p2、…排列数字。
，pn，他想要最大化价值。
Mini=1n−1|pi+1−pi|，
其中|x|表示x的绝对值。
帮凯文做到这一点。
输入。
每个测试由多个测试用例组成。
第一行包含单个整数t(1≤t≤100)–测试用例的数量。
测试用例的描述如下。
每个测试用例的唯一行包含一个整数n(2≤n≤1000)-集合的大小。
输出。
对于每个测试用例，打印一行包含n个不同的整数p1、p2、…。
Pn(1≤pi≤n)描述最大化连续元素的最小绝对差的布置。
在形式上，您必须打印一个排列p，它最大化了值mini=1n−1|pi+1−pi|。
如果有多个最优解，请打印其中任何一个。
示例。
输入复制。
2.。
4.。
3.。
输出复制。
2 4 1 3。
1 2 3。
注意事项。
在第一个测试案例中，连续元素的最小绝对差等于Min{|4−2|，|1−4|，|3−1|}=Min{2，3，2}=2。很容易证明这个解是最优的。
在第二个测试案例中，数字1、2、3的每个排列都是最佳答案。
连续元素的最小绝对差等于1。
💖
分奇偶，奇数就是在偶数的前提加n
为什么能行呢
因为大-小就能使得最大的在离前面的差大

2022-11-12
B.玩GCD。
您将看到一个长度为n的整数数组a。
是否存在由n+1个正整数组成的数组b，使得所有i(1≤i≤n)都有ai=gcd(bi，bi+1)？
注意，gcd(x，y)表示整数x和y的最大公约数(Gcd)。
输入。
每个测试包含多个测试用例。
第一行包含测试用例的数量t(1≤t≤105)。
测试用例的描述如下。
每个测试用例的第一行包含一个整数n(1≤n≤105)–数组a的长度。
每个测试用例的第二行包含n个空格分隔的整数a1、a2、…。
，An表示阵列a(1≤ai≤104)。
可以保证所有测试用例上的n之和不超过105。
输出。
对于每个测试用例，如果存在这样的b，则输出“yes”，否则输出“no”。
您可以用任何大小写(大写或小写)打印每个字母。
示例。
输入复制。
4.。
1。
343。
2.。
4 2。
3.。
4 2 4。
4.。
1 1 1。
输出复制。
是。
是。
不是的。
是。
注意事项。
在第一个测试用例中，我们可以取b=[343,343]。
在第二个测试用例中，b的一种可能性是b=[12，8，6]。
在第三个测试用例中，可以证明不存在任何满足所有条件的数组b。
💔
对于,ai-1,ai,ai+1
有bi-1,bi,bi+1,bi+2;
则有
gcd(bi-1,bi)=ai-1
gcd(bi,bi+1）=ai;
gcd(bi+2,bi+1）=ai+1;
所以可以知道，bi的因子里含有ai-1和ai，
bi+1的因子里含有ai和ai+1，那么此时{与ai约分后的ai+1}和{与ai约分后的ai-1}一定互质
因为我们已经知道，bi的因子里有ai-1和ai，bi+1的因子里有ai+1；如果{与ai约分后的ai+1}和{与ai约分后的ai-1}不互质，那么bi和bi+1的最大公约数一定是ai的k倍（k=2,3,4,……）

2022-11-13 e127
B.连续点分段。
您将获得在一个坐标轴OX上具有整数坐标的n个点。
第i点的坐标为xi。
所有点的坐标都是不同的，并且严格按递增顺序给出。
对于每个点i，您只能执行以下操作一次：取此点并将其向左或向右移动1(即，您可以将其坐标xi更改为xi−1或xi+1)。
换句话说，对于每个点，您(分别)选择它的新坐标。
对于第i个点，它可以是xi−1、xi或xi+1。
您的任务是确定是否可以如上所述移动一些点，使新的点集形成一个连续的整数段，即 。对于某个整数l，点的坐标应该等于l，l+1，…。
，l+n−1.。
请注意，生成的点应该具有不同的坐标。
您必须回答t个独立的测试用例。
输入。
输入的第一行包含一个整数t(1≤t≤2⋅104)–测试用例的数量。
然后是t个测试用例。
测试用例的第一行包含一个整数n(1≤n≤2⋅105)-集合x中的点数。
测试用例的第二行包含n个整数x1。
<xn(1≤xi≤106)，其中xi是第i点的坐标。
保证这些点按严格递增的顺序给出(这也意味着所有坐标都是不同的)。
还保证n的和不超过2⋅105(∑n≤2⋅105)。
输出。
对于每个测试用例，打印答案-如果测试用例中的点集可以移动以形成一个连续的整数段，则打印是，否则打印否。
示例。
输入复制。
5.。
2.。
1 4。
3.。
1 2 3。
4.。
1 2 3 7。
1。
1000000。
3.。
2 5 6。
输出复制。
是。
是。
不是的。
是。
是
💔
最多允许空有两个；
空的定义：大于2