2019 第十六届浙江省赛部分题解
A:Vertices in the Pocket
DreamGrid has just found an undirected simple graph with n vertices and no edges (that's to say, it's a graph with n isolated vertices) in his right pocket, where the vertices are numbered from 1 to n. Now he would like to perform q operations of the following two types on the graph:
- 1 a b -- Connect the a-th vertex and the b-th vertex by an edge. It's guaranteed that before this operation, there does not exist an edge which connects vertex a and b directly.
- 2 k -- Find the answer for the query: What's the minimum and maximum possible number of connected components after adding k new edges to the graph. Note that after adding the k edges, the graph must still be a simple graph, and the query does NOT modify the graph.
Please help DreamGrid find the answer for each operation of the second type. Recall that a simple graph is a graph with no self loops or multiple edges.
Input
There are multiple test cases. The first line of the input is an integer T, indicating the number of test cases. For each test case:
The first line contains two integers n and q (1≤n≤105, 1≤q≤2×105), indicating the number of vertices and the number of operations.
For the following q lines, the i-th line first contains an integer pi (pi∈{1,2}), indicating the type of the i-th operation.
- If pi=1, two integers ai and bi follow (1≤ai,bi≤n, ai≠bi), indicating an operation of the first type. It's guaranteed that before this operation, there does not exist an edge which connects vertex a and b directly.
- If pi=2, one integer ki follows (0≤ki≤n(n−1)2), indicating an operation of the second type. It's guaranteed that after adding ki edges to the graph, the graph is still possible to be a simple graph.
It's guaranteed that the sum of n in all test cases will not exceed 106, and the sum of q in all test cases will not exceed 2×106.
Output
For each operation of the second type output one line containing two integers separated by a space, indicating the minimum and maximum possible number of connected components in this query.
Sample Input
1
5 5
1 1 2
2 1
1 1 3
2 1
2 3
Sample Output
3 3
2 3
1 2
题意：开始有n个独立节点，有两种操作，第一种操作：将点x和y连接；第二种操作：询问在将图内添加m条边后，联通块最少和最多的个数。
方法：最少的个数很好求，就是当前剩下的联通块减去添加的边的条数和1取较大值。而最多的个数就复杂了很多了。我知道的方法是线段树加二分。建立一棵树，叶子节点的编号表示联通块的大小，节点内存储大小为k的块的个数，可容纳的边的条数还有点的个数。最后查询的时候进行二分。但是这样我们二分到叶子节点k时就不知道要合并掉多少个大小为k的块了，所以我们在子叶子节点这里再做一次二分，这样复杂度仍然只有一个log2(n)，因为每次查询我们只会到一个子叶节点。
#include
#define mid (l+r)/2
using namespace std;
const int maxn=1e5+5;
int n,m,father[maxn],num[maxn];
struct node
{
int point_num;//子树的点的个数之和
long long edeg_num;//可容纳边的条数
int num;//子树的块的个数
}no[maxn<<2];
void pushup(int cur)
{
no[cur].edeg_num = no[cur<<1].edeg_num + no[cur<<1|1].edeg_num;
no[cur].num = no[cur<<1].num+ no[cur<<1|1].num;
no[cur].point_num = no[cur<<1].point_num + no[cur<<1|1].point_num;
}
int find(int x)
{
return father[x]==x ? x : father[x]=find(father[x]);
}
void merge(int x,int y)
{
father[find(y)]=find(x);
}
void bulid(int l,int r,int loc)
{
if(r==1)
//此时一定到了叶子节点了，并且此叶子节点的编号为1
{
no[loc].edeg_num=0;
no[loc].num = no[loc].point_num=n;
return;
//表示大小为1的联通块的个数有n个，故子树的块数为n
}
else
{
no[loc].edeg_num = no[loc].num = no[loc].point_num=0;
//其他大小的块个数为0
}
if(l != r)
{
bulid(l,mid,loc<<1);//宏定义了mid
bulid(mid+1,r,loc<<1|1);
}
}
void add(int l,int r,int loc,int x)
{
if(l==r)
{
no[loc].point_num+=l;//添加了一个含有x个点的联通块
no[loc].edeg_num+=l*(l-1)/2;//x点最多可容纳的边的条数
no[loc].num++;//块的个数加一
return;
}
if(x<=mid)
{
add(l,mid,loc<<1,x);
}
else
{
add(mid+1,r,loc<<1|1,x);
}
pushup(loc);
}
void erase(int l,int r,int loc,int x)
{
if(l==r)
{
no[loc].point_num-=l;//删除了一个含有x个点的联通块
no[loc].edeg_num-=l*(l-1)/2;//x点最多可容纳的边的条数
no[loc].num--;//块的个数减一
return;
}
if(x<=mid)
{
erase(l,mid,loc<<1,x);
}
else
{
erase(mid+1,r,loc<<1|1,x);
}
pushup(loc);
}
int query(int l,int r,int loc,long long k,long long v)
{
if(v > n)exit(0);
if(k<=0)return 1;
if(l==r)
{
int ll=1,rr=no[loc].num;//二分合并块的个数
while(ll < rr)
{
int mmid=(ll+rr)>>1;
if((v+mmid*l)*(v+mmid*l-1)/2 >= l*(l-1)/2*mmid+k)rr=mmid;
else ll=mmid+1;
}
return ll;
}
else
{
//优先合并右子树，因为右子树的块比左子树的块大，需要融合的块会少一些
if((v+no[loc<<1|1].point_num)*(v+no[loc<<1|1].point_num-1)/2 >= k+no[loc<<1|1].edeg_num)
return query(mid+1,r,loc<<1|1,k,v);
else
return query(l,mid,loc<<1,k+no[loc<<1|1].edeg_num,v+no[loc<<1|1].point_num)+no[loc<<1|1].num;
}
}
int main()
{
scanf("%*d");
while(scanf("%d %d",&n,&m)==2)
{
for(int i=1;i<=n;i++)
{
father[i]=i;
num[i]=1;
}
long long max_edge=0;//在不减少联通块的情况下能添加的最多边数
int ans=n;//联通块的个数
bulid(1,n,1);
while(m--)
{
int op;
scanf("%d",&op);
if(op==1)
{
int x,y;
scanf("%d %d",&x,&y);
int fx=find(x),fy=find(y);
if(fx != fy)
{
erase(1,n,1,num[fx]);//删除一个点的个数为num[fx]的块
erase(1,n,1,num[fy]);
max_edge -= num[fx]*(num[fx]-1)/2;
max_edge -= num[fy]*(num[fy]-1)/2;
num[fx] = num[fx]+num[fy];
max_edge += num[fx]*(num[fx]-1)/2;
add(1,n,1,num[fx]);
merge(x,y);
ans--;
}
max_edge--;
}
else
{
long long x;
scanf("%lld",&x);
int ww=query(1,n,1,x-max_edge,0);
printf("%d %d\n",max(1ll,ans-x),ans+1-ww);
}
}
}
} B:Element Swapping
DreamGrid has an integer sequence a1,a2,…,an and he likes it very much. Unfortunately, his naughty roommate BaoBao swapped two elements ai and aj (1≤i What's worse is that DreamGrid cannot remember his precious sequence. What he only remembers are the two values x=∑k=1nkakandy=∑k=1nka2k Given the sequence after swapping and the two values DreamGrid remembers, please help DreamGrid count the number of possible element pairs (ai,aj) BaoBao swaps. Note that as DreamGrid is poor at memorizing numbers, the value of x or y might not match the sequence, and no possible element pair can be found in this situation. Two element pairs (ai,aj) (1≤i Input There are multiple test cases. The first line of the input contains an integer T, indicating the number of test cases. For each test case: The first line contains three integers n, x and y (2≤n≤105,1≤x,y≤1018), indicating the length of the sequence and the two values DreamGrid remembers. The second line contains n integers b1,b2,…,bn (1≤bi≤105), indicating the sequence after swapping. It's guaranteed that ∑k=1nkbk≤1018 and ∑k=1nkb2k≤1018. It's guaranteed that the sum of n of all test cases will not exceed 2×106. Output For each test case output one line containing one integer, indicating the number of possible element pairs BaoBao swaps. Sample Input Sample Output 题意：给定一个序列，这个序列有两个数字ai 和 aj 被交换位置了，现给出交换前计算出的X和Y。问被交换的ai 和 aj有几种可能。 方法： 用题目给的方法计算出当前序列的XY，用原来的减去现在的，结果如下： 2式除1式，得到a[i] + a[j]。特判一下式子的右边等于0的情况 BaoBao has just found an array A={a1,a2,…,an} of n integers in his left pocket. As BaoBao is bored, he decides to rearrange it into another array B={b1,b2,…,bn} of n integers such that B is a permutation of A, and ai≠bi for all 1≤i≤n. Please help BaoBao finish the rearragement. If multiple valid rearrangements exist, find the smallest one among them. Consider two arrays C={c1,c2,…,cn} and D={d1,d2,…,dn}, we say C is smaller than D if there exists an integer k such that 1≤k≤n, ci=di for all 1≤i Input There are multiple test cases. The first line of the input contains an integer T, indicating the number of test cases. For each test case: The first line contains an integer n (1≤n≤105), indicating the length of the array. The second line contains n integers a1,a2,…,an (1≤ai≤n), indicating the given array. Output For each test case output one line containing n integers b1,b2,…,bn separated by a space, indicating the answer. If there are multiple valid answers, output the smallest one. If no valid answer exists, print "Impossible" (without quotes) instead. Please, DO NOT output extra spaces at the end of each line, or your answer may be considered incorrect! Sample Input Sample Output 题意：给定一个a序列，输出字典序最小的b[i] 不等于a[i]的b序列。 方法：只有当某个数的个数有一半以上才会是无解的，其他情况都是有解的。但需要注意人为造成无解的情况，例如 序列：2 3 4 4 4 3 如果第一个数字填的是3，就会造成无解的情况。所以第一个数字必须填4。 我们可以用一个数组记录【待填的个数+不能填的位置】。则当数字x【待填的个数+不能填的位置】等于【当前剩余位置的个数】时，此位置必须填x。否则就选当前字典序最小的填入当前位置。 se,se2;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
num[a[i]]++;//num记录a[i]待填的个数
num2[a[i]]+=2;//num2记录a[i]待填的个数+b数组中不能填a[i]的位置的个数。开始的时候就是a[i]的个数的两倍
}
for(int i=1;i<=n;i++)
{
if(num[i])
{
se.insert(p(i,num[i]));//值与个数对应
se2.insert(p(num2[i],i));//个数与值对应
}
}
if((--se2.end())->first > n)
{
printf("Impossible\n");
continue;
}
for(int i=1;i<=n;i++)
{
se2.erase(p(num2[a[i]],a[i]));
se2.insert(p(--num2[a[i]],a[i]));//a[i]不可填的位置个数少了一个，但待填的个数不变，故减一
p maxx=*(--se2.end());//se2的最后一个元素，即最大的【代填个数+不可填位置】
if(maxx.first == n-i+1)//若x待填的位置+不可填的位置个数的和 为 当前剩余的位置个数。\
表明当前位置必须填x。若不填a[i],后面就会造成无解的情况
{
b[i]=maxx.second;
}
else//若并非必须填x，则填入字典序最小的。这样可以保证最后得到的序列字典序最小
{
if(a[i]==(se.begin())->first)//若集合中字典序最小的那个与a[i]相同，则填入字典序第二小的
{
b[i]=(++se.begin())->first;
}
else
{
b[i]=(se.begin())->first;
}
}
se.erase(p(b[i],num[b[i]]));se2.erase(p(num2[b[i]],b[i]));
if(--num[b[i]])//若b[i]待填的个数不为零，则添加
{
se.insert(p(b[i],num[b[i]]));
}
if(--num2[b[i]])
{
se2.insert(p((num2[b[i]]),b[i]));
}
}
for(int i=1;i<=n;i++)
{
if(i!=1)printf(" ");
printf("%d",b[i]);
}
printf("\n");
}
} DreamGrid has just found an integer sequence in his right pocket. As DreamGrid is bored, he decides to play with the sequence. He can perform the following operation any number of times (including zero time): select an element and move it to the beginning of the sequence. What's the minimum number of operations needed to make the sequence non-decreasing? Input There are multiple test cases. The first line of the input contains an integer , indicating the number of test cases. For each test case: The first line contains an integer (), indicating the length of the sequence. The second line contains integers (), indicating the given sequence. It's guaranteed that the sum of of all test cases will not exceed . Output For each test case output one line containing one integer, indicating the answer. Sample Input Sample Output 题意：给定n个数字，每个数字只能将其移动到第一个位置，求构成非递减序列最少需要移动几次。 方法：找到最大数，最大的数是可以不移动的。然后在最大的数前面找次大的数，找得到就继续找次次大的数。找到的这几个数都是可以不移动的。而其他的数都一定是需要移动的。 In the Test of English as a Foreign Language (TOEFL), the listening part is very important but also very hard for most students since it is usually quite hard for them to remember the whole passage. To help themselves memorize the content, students can write down some necessary details. However, it is not easy to write down the complete word because of its length. That's why we decide to use the abbreviation to express the whole word. It is very easy to get the abbreviation, all we have to do is to keep the consonant letters and erase the vowel. In the English alphabet, we regard 'a', 'e', 'i', 'y', 'o', 'u' as the vowels and the other letters as the consonants. For example, "subconscious" will be expressed as "sbcnscs". However, there is one exception: if the vowel appears as the first letter, they should be kept instead of thrown away. For example, "oipotato" should be expressed as "optt". Since you have learned how to use the abbreviation method, it's time for some exercises. We now present you words in total, it's your task to express them in their abbreviation form. Input There are multiple test cases. The first line of the input contains an integer (about 100), indicating the number of test cases. For each test case: The only line contains a string () consisting of lowercase English letters, indicating the word which needs to be abbreviated. Output For each test case output one line containing one string, which is the correct abbreviation of the given word. Sample Input Sample Output 题意：给定一个字符串，将除第一个字符以外其他所有 'a', 'e', 'i', 'y', 'o', 'u' 删掉，输出删除后的串。 方法：水题，直接模拟就好。 BaoBao loves number 7 but hates number 4, so he refers to an integer as a "lucky integer" if is divisible by 7 but not divisible by 4. For example, 7, 14 and 21 are lucky integers, but 1, 4 and 28 are not. Today BaoBao has just found an integer in his left pocket. As BaoBao dislikes large integers, he decides to find a lucky integer such that and is as small as possible. Please help BaoBao calculate the value of . Input There are multiple test cases. The first line of the input is an integer (about 100), indicating the number of test cases. For each test case: The first and only line contains an integer (), indicating the integer in BaoBao's left pocket. Output For each test case output one line containing one integer, indicating the value of . Sample Input Sample Output 题意：输出最小的比n大的是7的倍数但不是4的倍数的数字。 Baobao loves singing very much and he really enjoys a game called Singing Everywhere, which allows players to sing and scores the players according to their performance. Consider the song performed by Baobao as an integer sequence , where indicates the -th note in the song. We say a note is a "voice crack" if , and . The more voice cracks BaoBao sings, the lower score he gets. To get a higher score, BaoBao decides to delete at most one note in the song. What's the minimum number of times BaoBao sings a voice crack after this operation? Input There are multiple test cases. The first line of the input contains an integer (about 100), indicating the number of test cases. For each test case: The first line contains one integer (), indicating the length of the song. The second line contains integers (), indicating the song performed by BaoBao. It's guaranteed that at most 5 test cases have . Output For each test case output one line containing one integer, indicating the answer. Sample Input Sample Output 题意：最多删除一个数，使序列中的峰最少。 方法：暴力枚举出所有的峰，然后模拟。(代码很长，以后再缩) DreamGrid has just found a Fibonacci sequence and two integers and in his right pocket, where indicates the -th element in the Fibonacci sequence. Please tell DreamGrid if is even or is odd. Recall that a Fibonacci sequence is an infinite sequence which satisfies , and for all . Input There are multiple test cases. The first line of the input contains an integer (about 100), indicating the number of test cases. For each test case: The first and only line contains two integers and (). Their meanings are described above. Output For each test case output one line. If is even output "0" (without quotes); If is odd output "1" (without quotes). Sample Input Sample Output 题意：判断斐波那契数列a到b区间的和的奇偶性。 方法：我们可以发现数列的奇偶性为：奇奇偶 奇奇偶 奇奇偶 奇奇偶。任意连续的三个数的和都是偶数。可知若区间长度取余三为零，则和一定为偶数。若余1，我们可假设余下的那一个是该区间的第一个数(最后一个数也可以)，那么只要判断这个数的奇偶性即可。若余二，可以假设余下的是该区间的第一个和第二个，那么只要判断前两个数的和的奇偶性即可。 例如给定的是a和b，可知：区间长度为len=(b-a+1)，若len%3==0,直接输出0即可，否则输出1. 若len%3==1，我们需要判断a%3的值，若a%3==0，可知第a个数是偶数，否则是奇数。 若len%3==2，若a%3==1,可知第a个数和第a+1个数都是奇数，前两个数的和是偶数，否则前两个数的和一定是奇数。 方法二：可以看出前缀和奇偶性为：奇偶偶 奇偶偶 奇偶偶 奇偶偶。 这样我们只要把a和b取余三判断一下即可。只有 奇-奇 或 偶-偶是输出0，其他都输出1。 c++版本待补。 The 44th World Finals of the International Collegiate Programming Contest (ICPC 2020) will be held in Moscow, Russia. To celebrate this annual event for the best competitive programmers around the world, it is decided to host a welcome party for all participants of the World Finals, numbered from to for convenience. The party will be held in a large hall. For security reasons, all participants must present their badge to the staff and pass a security check in order to be admitted into the hall. Due to the lack of equipment to perform the security check, it is decided to open only one entrance to the hall, and therefore only one person can enter the hall at a time. Some participants are friends with each other. There are pairs of mutual friendship relations. Needless to say, parties are more fun with friends. When a participant enters the hall, if he or she finds that none of his or her friends is in the hall, then that participant will be unhappy, even if his or her friends will be in the hall later. So, one big problem for the organizer is the order according to which participants enter the hall, as this will determine the number of unhappy participants. You are asked to find an order that minimizes the number of unhappy participants. Because participants with smaller numbers are more important (for example the ICPC director may get the number 1), if there are multiple such orders, you need to find the lexicographically smallest one, so that important participants enter the hall first. Please note that if participant and are friends, and if participant and are friends, it's NOT necessary that participant and are friends. Input There are multiple test cases. The first line of the input contains a positive integer , indicating the number of cases. For each test case: The first line contains two integers and (), the number of participants and the number of friendship relations. The following lines each contains two integers and (), indicating that the -th and the -th participant are friends. Each friendship pair is only described once in the input. It is guaranteed that neither the sum of nor the sum of of all cases will exceed . Output For each case, print a single integer on the first line, indicating the minimum number of unhappy participants. On the second line, print a permutation of to separated by a space, indicating the lexicographically smallest ordering of participants entering the hall that achieves this minimum number. Consider two orderings and , we say is lexicographically smaller than , if there exists an integer (), such that holds for all , and . Please, DO NOT output extra spaces at the end of each line, or your solution may be considered incorrect! Sample Input Sample Output 题意：n个人，m个关系，n个人进入会场，如果会场没有认识的人，则这个人会不高兴。注意，朋友关系之间不可传递，朋友的朋友不一定是朋友。要求不高兴的人数最少，并且输出字典序最小的入场方案。 方法：优先队列+并查集 BaoBao has just found two strings and in his left pocket, where indicates the -th character in string , and indicates the -th character in string . As BaoBao is bored, he decides to select a substring of and reverse it. Formally speaking, he can select two integers and such that and change the string to . In how many ways can BaoBao change to using the above operation exactly once? Let be an operation which reverses the substring , and be an operation which reverses the substring . These two operations are considered different, if or . Input There are multiple test cases. The first line of the input contains an integer , indicating the number of test cases. For each test case: The first line contains a string (), while the second line contains another string (). Both strings are composed of lower-cased English letters. It's guaranteed that the sum of of all test cases will not exceed . Output For each test case output one line containing one integer, indicating the answer. Sample Input Sample Output 题意：给两个字符串a和b，可以翻转a串的一个区间，使ab两串相等。问有多少个这样的区间。 方法：若两个串不相等，找到第一个不等和最后一个不等的位置，判断这个区间翻转过来能不能和第二个串相同。如果可以，就继续往外面扩散。 若两个串相等，用manacher找回文子串的个数。 特判只有一个字符不等的时候，减少时间复杂度。因为这题好像时间卡的特别死，多两个memset就超时了。 详情请看代码理解 2
6 61 237
1 1 4 5 1 4
3 20190429 92409102
1 2 3
2
0
![(i-j)*(a[j]-a[i])=X-\sum_{i=1}^{n}k*a[i]](http://img.e-com-net.com/image/info8/58d9afed08944a6b84566f6aaf019b51.gif)
(1)![(i-j)*(a[j]^{2}-a[i]^{2})=Y-\sum_{i=1}^{n}k*a[i]^{2}](http://img.e-com-net.com/image/info8/3b00316b0e174b30b65c24dbd45b17bb.gif)
(2)#include C:Array in the Pocket
3
4
4 1 3 2
4
1 1 2 3
3
1 1 1
1 2 4 3
2 3 1 1
Impossible
#include D:Traveler
E:Sequence in the Pocket
2
4
1 3 2 4
5
2 3 3 5 5
2
0
#include F:Abbreviation
5
subconscious
oipotato
word
symbol
apple
sbcnscs
optt
wrd
smbl
appl
#include G:Lucky 7 in the Pocket
4
1
7
20
28
7
7
21
35
#includeH:Singing Everywhere
3
6
1 1 4 5 1 4
7
1 9 1 9 8 1 0
10
2 1 4 7 4 8 3 6 4 7
1
0
2
#include I:Fibonacci in the Pocket
6
1 2
1 3
1 4
1 5
123456 12345678987654321
123 20190427201904272019042720190427
0
0
1
0
0
1
input()
while True:
try:
a,b=map(int,raw_input().split(" "))#输入,并分别赋值给a和b
y=int(b)-int(a)+1;#y是区间长度
if y%3 == 0:
print(0)
else:
w = a%3
if y%3 == 1:
if w == 0:
print(0)
else:
print(1)
else:
if w == 1:
print(0)
else:
print(1)
except:
breakJ:Welcome Party
2
4 3
1 2
1 3
1 4
4 2
1 2
3 4
1
1 2 3 4
2
1 2 3 4
#include K:Strings in the Pocket
2
abcbcdcbd
abcdcbcbd
abc
abc
3
3
#include