第四周周报

本周了解到了一些新函数isalpha(char)判断是否为字母，isdigit(char)判断是否为数字0~9；getline(cin,s);其中s为string类型，cin.getline(a,n)a为数组名，n为大小;reverse()翻转字符串;怎样写仿函数改变sort排序规则；还学习了并查集算法以及它的压缩路径，dfs算法思想；

题目：7-6 福到了

“福”字倒着贴，寓意“福到”。不论到底算不算民俗，本题且请你编写程序，把各种汉字倒过来输出。这里要处理的每个汉字是由一个 N × N 的网格组成的，网格中的元素或者为字符 @ 或者为空格。而倒过来的汉字所用的字符由裁判指定。

输入格式：
输入在第一行中给出倒过来的汉字所用的字符、以及网格的规模 N （不超过100的正整数），其间以 1 个空格分隔；随后 N 行，每行给出 N 个字符，或者为 @ 或者为空格。

输出格式：
输出倒置的网格，如样例所示。但是，如果这个字正过来倒过去是一样的，就先输出bu yong dao le，然后再用输入指定的字符将其输出。

输入样例 1：
$ 9
 @  @@@@@
@@@  @@@ 
 @   @ @ 
@@@  @@@ 
@@@ @@@@@
@@@ @ @ @
@@@ @@@@@
 @  @ @ @
 @  @@@@@
输出样例 1：
$$$$$  $ 
$ $ $  $ 
$$$$$ $$$
$ $ $ $$$
$$$$$ $$$
 $$$  $$$
 $ $   $ 
 $$$  $$$
$$$$$  $ 
输入样例 2：
& 3
@@@
 @ 
@@@
输出样例 2：
bu yong dao le
&&&
 & 
&&&

解析：

本题要输入一个图案后，输出其倒的图案，并且要将原本的字符替换为指定的字符；如果倒着与正着一样还要输出"bu yong dao le"；本题一个字符串数组就可以搞定。需要先判断正着和倒着是否一样，之后再倒着输出指定字符就可以了。当时没做出来是因为又开了一个数组倒着把字符填进去，导致输出一直不对；还应该注意用cin.getline()之前如果输入了其他数据需要用getchar()读取回车；

代码：

#include<stdio.h>
int main(){
    char c;
    int n;
    char a[101][101],b[101][101];
    scanf("%c %d",&c,&n);
    getchar();
    for(int i=0;i<n;i++){
        gets(a[i]);
    }int r=0;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(a[i][j]!=a[n-1-i][n-j-1]){
                r=1;
                break;
            }
        }
    }
    if(r==0){
        printf("bu yong dao le\n");
    }

    for(int k=0,i=n-1;i>=0;i--,k++){
        for(int t=0,j=n-1;j>=0;j--,t++){
            if(a[i][j]=='@') printf("%c",c);
            else printf(" ");
        }
        printf("\n");
    }
    return 0;       
}

题目：抢红包

没有人没抢过红包吧…… 这里给出N个人之间互相发红包、抢红包的记录，请你统计一下他们抢红包的收获。

输入格式：
输入第一行给出一个正整数N（≤10 
4
 ），即参与发红包和抢红包的总人数，则这些人从1到N编号。随后N行，第i行给出编号为i的人发红包的记录，格式如下：

KN 
1
​
 P 
1
​
 ⋯N 
K
​
 P 
K
​
 

其中K（0≤K≤20）是发出去的红包个数，N 
i
​
 是抢到红包的人的编号，P 
i
​
 （>0）是其抢到的红包金额（以分为单位）。注意：对于同一个人发出的红包，每人最多只能抢1次，不能重复抢。

输出格式：
按照收入金额从高到低的递减顺序输出每个人的编号和收入金额（以元为单位，输出小数点后2位）。每个人的信息占一行，两数字间有1个空格。如果收入金额有并列，则按抢到红包的个数递减输出；如果还有并列，则按个人编号递增输出。

输入样例：
10
3 2 22 10 58 8 125
5 1 345 3 211 5 233 7 13 8 101
1 7 8800
2 1 1000 2 1000
2 4 250 10 320
6 5 11 9 22 8 33 7 44 10 55 4 2
1 3 8800
2 1 23 2 123
1 8 250
4 2 121 4 516 7 112 9 10
输出样例：
1 11.63
2 3.63
8 3.63
3 2.11
7 1.69
6 -1.67
9 -2.18
10 -3.26
5 -3.26
4 -12.32

解析：

本题题意：对每个人收入金额递减顺序排列，金额一样看抢到红包数，红包数也一样就看编号递增输出；因此需要使用结构体记录每个人的编号，拥有的钱数，和抢到红包的个数，对每个编号的人发红包时需要减去他发的红包金额，他发的被哪个编号的人抢了，那个人要加红包金额和抢到红包个数，在对所有人的发出，收到红包记录完成之后进行排序，用sort自己按照题目要求定义仿函数。最后按顺序输出。

代码：

#include<bits/stdc++.h>
using namespace std;
struct reaad{
    int id;
    long long  sum;
    int g;
}a[10010],temp;
int compare(reaad x,reaad y){//仿函数，重新定义比较比较规则
    if(y.sum!=x.sum){
        return x.sum>y.sum;//为真是输出第一个参数
    }
    if(y.g!=x.g){
        return x.g>y.g;
    }
    if(x.id!=y.id){
        return x.id<y.id;
    }
}
int main(){
    int n;
    cin>>n;
    int k,x,p;
    for(int i=1;i<=n;i++){
        cin>>k;
        a[i].id=i;
        for(int j=0;j<k;j++){
            cin>>x>>p;
            a[i].sum-=p;
            a[x].sum+=p;
            a[x].g++;
        }
    }
    sort(a+1,a+n+1,compare);
    for(int i=1;i<=n;i++){
        cout<<a[i].id<<" ";
        printf("%.2f\n",a[i].sum*1.000/100);//按照题目格式输出
    }
    return 0;
}

题目：红色警报

战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序，当失去一个城市导致国家被分裂为多个无法连通的区域时，就发出红色警报。注意：若该国本来就不完全连通，是分裂的k个区域，而失去一个城市并不改变其他城市之间的连通性，则不要发出警报。

输入格式：
输入在第一行给出两个整数N（0 < N ≤ 500）和M（≤ 5000），分别为城市个数（于是默认城市从0到N-1编号）和连接两城市的通路条数。随后M行，每行给出一条通路所连接的两个城市的编号，其间以1个空格分隔。在城市信息之后给出被攻占的信息，即一个正整数K和随后的K个被攻占的城市的编号。

注意：输入保证给出的被攻占的城市编号都是合法的且无重复，但并不保证给出的通路没有重复。

输出格式：
对每个被攻占的城市，如果它会改变整个国家的连通性，则输出Red Alert: City k is lost!，其中k是该城市的编号；否则只输出City k is lost.即可。如果该国失去了最后一个城市，则增加一行输出Game Over.。

输入样例：
5 4
0 1
1 3
3 0
0 4
5
1 2 0 4 3
输出样例：
City 1 is lost.
City 2 is lost.
Red Alert: City 0 is lost!
City 4 is lost.
City 3 is lost.
Game Over.

解析：

本道题需要使用到并查集算法。使用二维数组将所有的连通城市记录下来，以便之后判断；对于每攻占一个城市，使用并查集得到城市之间的连通性，与之前的连通性作比较；需注意的是没有改变连通性的城市不需要发出警报，具体操作见代码。

代码：

#include<bits/stdc++.h>
using namespace std;
int f[505],v[50500][2],vis[505];//vis记录被攻占的城市，v记录两座的连通路，f为并查集
int find(int x){
    if(f[x]==x) return x;
    else return f[x]=find(f[x]);//找到根节点为止
}
void jion(int x,int y){
    x=find(x);
    y=find(y);
    if(x!=y){//如果没有指向同一个根节点，将x,y连通，y作为父节点
        f[x]=y;
    }
}
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++) f[i]=i;
    int t=0;
    for(int i=0;i<m;i++){
        cin>>v[i][0]>>v[i][1];
        jion(v[i][0],v[i][1]);
    }
    int cout1=0,cout2=0;//cout1记录攻占前，cout2记录攻占后连通性
    for(int i=0;i<n;i++) if(f[i]==i) cout1++;
    int k;
    cin>>k;
    while(k--){
        int x;
        cout2=0;
        cin>>x;
        vis[x]=1;
        for(int i=0;i<n;i++) f[i]=i;
        for(int i=0;i<m;i++){
            if(vis[v[i][0]]!=1&&vis[v[i][1]]!=1){//已经被攻占的城市的连通路不需要再将它们连在一起
                jion(v[i][0],v[i][1]);
            }
        }
        for(int j=0;j<n;j++) if(f[j]==j&&vis[j]!=1) cout2++;//已被攻占的城市不需要在进行判断
        if(cout1==cout2||cout1==cout2+1){//cout1==cout2+1是因为被攻占的城市可能原本就不和其他城市连通，不对已被攻占的城市记录时，cout2可能会减少一个，但连通性并没有改变。
            printf("City %d is lost.\n",x);
        }
        else{
            printf("Red Alert: City %d is lost!\n",x);
        } 
        cout1=cout2;
    }
    int c=0;
    for(int i=0;i<n;i++) if(vis[i]==1) c++;//利用vis判断是否所有城市都被攻占
    if(c==n) printf("Game Over.");//全部被攻占输出Game Over;
    return 0;
}

题目：D. Product of Binary Decimals（Codeforces Round 937 (Div. 4)

如果一个数是正整数，且其十进制符号中的所有数字都是 $$$0$$$ 或 $$$1$$$ ，我们就称它为二进制十进制数。例如， $$$1\\,010\\,111$$$ 是二进制十进制，而 $$$10\\,201$$$ 和 $$$787\\,788$$$ 不是。

给定一个数 $$$n$$$ ，问你是否可以将 $$$n$$$ 表示为一些(不一定不同的)二进制小数的乘积。

**输入**

第一行包含一个整数 $$$t$$$ ( $$$1 \leq t \leq 5 \cdot 10^4$$$ ) - 测试用例数。

每个测试用例的唯一一行包含一个整数 $$$n$$$ ( $$$1 \leq n \leq 10^5$$$ )( $$$1 \leq n \leq 10^5$$$ ).

**输出**

对于每个测试用例，如果 $$$n$$$ 可以表示为二进制小数的乘积，则输出 "是"(不带引号)，否则输出 "否"(不带引号)。

您可以在任何情况下输出 "YES "和 "NO"(例如，字符串 "yES"、"yes "和 "Yes "将被视为肯定回答)。

解析：

本题就是要判断一个数n是否能够由像二进制的十进制数相乘得到，我们就可以用递归函数从最小的二进制十进制数开始对这个数是否能整除，如果判断到大于n的x且n没有为1，那这个数就不能被二进制十进制的数得到。

代码：

#include<bits/stdc++.h>
using namespace std;
int n;
void dfs(int x){//运用dfs查找是否n能以二进制数相乘得到；
    if(x>n) return;//结束条件
    while(n%x==0&&x!=1){
        n/=x;//将为x的因数全部除掉，最后如果刚好被整除n最后为1；
    }
    x*=10;//改变x的值
    dfs(x);
    x++;
    dfs(x);
}
int main(){
    int t;
    cin>>t;
    while(t--){
      cin>>n;
      dfs(1);
      if(n==1)cout<<"YES"<<endl;
      else cout<<"NO"<<endl;  
    }
    return 0;
}

题目：E. Nearly Shortest Repeating Substring（Codeforces Round 937 (Div. 4)

E.近最短重复子串

每次测试的时间限制：2 秒

每次测试的内存限制：256 兆字节

输入：标准输入

输出：标准输出

You are given a string $s$ of length $n$ consisting of lowercase Latin characters. Find the length of the shortest string $k$ such that several (possibly one) copies of $k$ can be concatenated together to form a string with the same length as $s$ and, at most, one different character.

More formally, find the length of the shortest string $k$ such that $c = \underbrace{k + \cdots + k}_{x\rm\ \text{times}}$ for some positive integer $x$, strings $s$ and $c$ has the same length and $c_i \neq s_i$ for at most one $i$ (i.e. there exist $0$ or $1$ such positions).

**Input**

The first line contains a single integer $t$ ($1 \leq t \leq 10^3$) — the number of test cases.

The first line of each test case contains a single integer $n$ ($1 \leq n \leq 2\cdot10^5$) — the length of string $s$.

The second line of each test case contains the string $s$, consisting of lowercase Latin characters.

The sum of $n$ over all test cases does not exceed $2\cdot10^5$.

**Output**

For each test case, print the length of the shortest string $k$ satisfying the constraints in the statement.

input

Copy

5

4

abaa

4

abba

13

slavicgslavic

8

hshahaha

20

stormflamestornflame

output

Copy

1
4
13
2
10

**Note**

In the first test case, you can select $k = \texttt{a}$ and $k+k+k+k = \texttt{aaaa}$, which only differs from $s$ in the second position.

In the second test case, you cannot select $k$ of length one or two. We can have $k = \texttt{abba}$, which is equal to $s$.

解析：

本题题意是给出字符串S找到最短的字符串k的长度，使字符串c=k+k+k....，s和k长度相等，且最多就只有一个ci!=si，因为最后字符串长度相等所以只需要枚举该串长度的因数，判断该长度的字符串是否为子串，注意判断的时候不仅需要以最前面的一个子串为模板遍历，还要与其他一个子串进行判断（样例第四组数据可以看出，如果只判断第一段子串，答案会为4），所以这里还选择了最后一个子串用来判断，满足任意一个就可以得到最小子串长度了。

**注**

在第一个测试案例中，您可以选择 $$$k = \texttt{a}$$$ 和 $$$k+k+k+k = \texttt{aaaa}$$$ ，它们与第二个位置上的 $$$s$$$ 只有区别。

在第二个测试用例中，无法选择长度为一或二的 $$$k$$$ 。我们可以选择 $$$k = \texttt{abba}$$$ ，它等于 $$$s$$$ 。

代码：

#include<bits/stdc++.h>
using namespace std;

int main(){
    int t;
    cin>>t;
    while(t--){
        int n,c;
        char a[200005];
        cin>>n;
        for(int i=0;i<n;i++){
            cin>>a[i];
        }
        for(int i=1;i<=n;i++){
            int c1=0,c2=0;
            if(n%i==0){//若i是其因数判断
                for(int j=0;j<n;j++){
                    if(a[j]!=a[j%i]){//以第一段为最小字串
                        c1++;
                    }
                    if(a[j]!=a[n+j%i-i]){//以最后一段为最小子串
                        c2++;
                    }
                }
                if(c1<2||c2<2){//满足两个任意一个就退出循环
                    c=i;
                    break;
            }            
            }
        }
        cout<<c<<endl;
    }
    return 0;
}

题目：连续因子

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。

输入格式：

输入在一行中给出一个正整数 N（1<N<231）。

输出格式：

首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1*因子2*……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。

输入样例：

630

输出样例：

3
5*6*7

解析：

本题需要解决的是找到一个正整数的最长连续因子个数，从n可以看出数据范围并不大，可以对因数枚举判断求解

代码：

#include<bits/stdc++.h>
using namespace std;
vector<long long> v;//记录最大连续因数
int main(){
    long long n;
    cin>>n;
    for(int i=2;i<=sqrt(n);i++){//sqrt(n)之后就不可能存在连续因数了；
        if(n%i==0){
            vector<long long>v1;//对每一个因数记录其连续因数
            long long x=n;
            v1.push_back(i);
            x/=i;
            for(int j=i+1;;j++){
                if(x%(j)==0){能继续被下个连续因数整除继续判断
                    x/=j;
                    v1.push_back(j);
                    continue;
                }
                else{
                    break;
                }
            }
            if(v.size()<v1.size()){//如果这个连续因数大于之前记录的交换；
                swap(v1,v);
            }
        }
    }
    if(v.size()==0) cout<<"1"<<endl<<n<<endl;//如果该数是素数那么他连续因数为本身且个数为一
    else{
        cout<<v.size()<<endl;
        for(int i=0;i<v.size()-1;i++) cout<<v[i]<<"*";//输出格式
        cout<<v[v.size()-1]<<endl;
    }
    return 0;
}

题目：文件运输

当两台计算机双向连通的时候，文件是可以在两台机器间传输的。给定一套计算机网络，请你判断任意两台指定的计算机之间能否传输文件？

输入格式：

首先在第一行给出网络中计算机的总数 N (2≤N≤104)，于是我们假设这些计算机从 1 到 N 编号。随后每行输入按以下格式给出：

I c1 c2  

其中I表示在计算机c1和c2之间加入连线，使它们连通；或者是

C c1 c2    

其中C表示查询计算机c1和c2之间能否传输文件；又或者是

S

这里S表示输入终止。

输出格式：

对每个C开头的查询，如果c1和c2之间可以传输文件，就在一行中输出"yes"，否则输出"no"。当读到终止符时，在一行中输出"The network is connected."如果网络中所有计算机之间都能传输文件；或者输出"There are k components."，其中k是网络中连通集的个数。

输入样例 1：

5
C 3 2
I 3 2
C 1 5
I 4 5
I 2 4
C 3 5
S

输出样例 1：

no
no
yes
There are 2 components.

输入样例 2：

5
C 3 2
I 3 2
C 1 5
I 4 5
I 2 4
C 3 5
I 1 3
C 1 5
S

输出样例 2：

no
no
yes
yes
The network is connected.

解析：

本题题意字母为c判断两个文件连通性，为i将他们连通，为s终止并判断连通集个数；容易想到该题需要使用并查集算法来将计算机连通，注意：需要压缩路径不让查找时容易超时。

代码：

#include<bits/stdc++.h>
using namespace std;
vector<int> v;
int find(int x){
    if(v[x]!=x){
        v[x]=find(v[x]);//让所有子结点直接指向他们的最终根节点，压缩查找路径
    }
    return v[x]; 
}

int main(){
    int n;
    cin>>n;
    int t=n;
    v.push_back(-1);
    for(int i=1;i<=n;i++){
        v.push_back(i);
    }
    while(1){
        int a,b;
        char f;
        cin>>f>>a>>b;
        if(f=='C'){//查找a,b根节点是否相同
            a=find(a);
            b=find(b);
            if(a!=b){
                cout<<"no"<<endl;
            }
            else{
                cout<<"yes"<<endl;
            }
        }
        else if(f=='I'){
            a=find(a);
            b=find(b);
            if(a!=b){//判断a,b节点是否来自一个连通集，不是的话改变其中一个根节点的指向；
                v[a]=b;
            }
        }
        else{
            int c=0;
            for(int i=1;i<=n;i++){
                if(v[i]==i){
                    c++;
                }
            }
            if(c==1) cout<<"The network is connected."<<endl;
            else{
                printf("There are %d components.\n",c);
            }
            break;
        }
    }
    return 0;
}

题目：病毒溯源

病毒容易发生变异。某种病毒可以通过突变产生若干变异的毒株，而这些变异的病毒又可能被诱发突变产生第二代变异，如此继续不断变化。

现给定一些病毒之间的变异关系，要求你找出其中最长的一条变异链。

在此假设给出的变异都是由突变引起的，不考虑复杂的基因重组变异问题 —— 即每一种病毒都是由唯一的一种病毒突变而来，并且不存在循环变异的情况。

输入格式：

输入在第一行中给出一个正整数 N（≤104），即病毒种类的总数。于是我们将所有病毒从 0 到 N−1 进行编号。

随后 N 行，每行按以下格式描述一种病毒的变异情况：

k 变异株1 …… 变异株k

其中 k 是该病毒产生的变异毒株的种类数，后面跟着每种变异株的编号。第 i 行对应编号为 i 的病毒（0≤i<N）。题目保证病毒源头有且仅有一个。

输出格式：

首先输出从源头开始最长变异链的长度。

在第二行中输出从源头开始最长的一条变异链，编号间以 1 个空格分隔，行首尾不得有多余空格。如果最长链不唯一，则输出最小序列。

注：我们称序列 { a1​,⋯,an​ } 比序列 { b1​,⋯,bn​ } “小”，如果存在 1≤k≤n 满足 ai​=bi​ 对所有 i<k 成立，且 ak​<bk​。

输入样例：

10
3 6 4 8
0
0
0
2 5 9
0
1 7
1 2
0
2 3 1

输出样例：

4
0 4 9 1

解析：

本题首先需要记录每一种病毒会变异成为其他的病毒，用vector数组记录他自己的编号为父节点，变异为其他的编号的病毒为子节点，并且还要找到唯一的源头病毒编号（即：它不做任意的病毒的子节点；找到之后就从此编号的病毒开始深度搜素并找到最底层之后开始回溯查找其他的点，temp记录最长变异链，dfs实现操作见代码；

代码：

#include<bits/stdc++.h>
using namespace std;
vector<int> v[10000],p,temp;
int pan[10000]={0};
void dfs(int x){
    if(p.size()>temp.size()){//将最长的变异链记录下来
        temp=p;
    }
    for(int i=0;i<v[x].size();i++){//遍历x的子节点
        p.push_back(v[x][i]);
        dfs(v[x][i]);
        p.pop_back();//到达最底端后开始回溯其他的点
    }
}
int main(){
    int n;
    cin>>n;
    int t=n;
    for(int i=0;i<n;i++){
        int k;
        cin>>k;
        for(int j=0;j<k;j++){
            int x;
            cin>>x;
            pan[x]=1;//判断是否成为了子节点
            v[i].push_back(x);
        }
        if(v[i].size()){
            sort(v[i].begin(),v[i].end());//可能有相同的变异链，所以提前按大小将子节点排序
        }
    }
    for(int i=0;i<n;i++){
        if(pan[i]==0){
            p.push_back(i);
            dfs(i);//从原病毒开始搜素
            break;
        }
    }
    cout<<temp.size()<<endl;
    for(int i=0;i<temp.size()-1;i++) cout<<temp[i]<<" ";
    cout<<temp[temp.size()-1];
}