Codeforces Round #615 (Div. 3) A-F简要题解

contest链接：https://codeforces.com/contest/1294

A.

给出a、b、c三个数，从n中分配给a、b、c，问能否使得a = b = c。计算a,b,c三个数的差值之和，n对其取余，判断是否为0即可。

AC代码：

     #include<iostream>
     #include<vector>
     #include<algorithm>
     #include<cmath>
     #include<cstring>
     #include<queue>
     #include<cstdio>
     #include<stack>
     #include<unordered_map>
     #define inf 0x3f3f3f3f
     using namespace std;
     typedef long long ll;
     int main(){
         int t;
         scanf("%d",&t);
         while(t--){
             int n,a,b,c;
             scanf("%d%d%d%d",&a,&b,&c,&n);
             if(a<b) swap(a,b);
             if(a<c) swap(a,c);
             if(b<c) swap(b,c);
             int dif = a - b + a - c;
             if((n - dif)% ==  && (n - dif)>=) printf("YES\n");
             else printf("NO\n");

         }
         return ;
     }

B. Collecting Packages

题意：给定一些点的坐标，问从起点开始移动，能否经过所有的点，且每次只能向上向右移动，求出路径。

思路：所有点按横纵坐标排序，扫一遍所有的点，每次先向右再向上走。

     #include<iostream>
     #include<vector>
     #include<algorithm>
     #include<cmath>
     #include<cstring>
     #include<queue>
     #include<cstdio>
     #include<stack>
     #include<unordered_map>
     #define inf 0x3f3f3f3f
     using namespace std;
     typedef long long ll;
     const int maxn = ;
     struct node{
         int x,y;
     };
     bool cmp(node a,node b){
         if(a.x == b.x ) return a.y < b.y ;
         return a.x < b.x ;
     }
     int main(){
         int t;
         scanf("%d",&t);
         while(t--){
             int n;
             scanf("%d",&n);
             node g[maxn];
             for(int i = ;i<=n;i++) {
                 scanf("%d%d",&g[i].x,&g[i].y);
             }
             sort(g+,g++n,cmp);
             string ans = "";
             int f = ;
             int curx = ,cury = ;
             for(int i = ;i<=n;i++){
                 if(i == ){
                     int lenR = g[i].x - curx;
                     int lenU = g[i].y - cury;
                     ans.append(lenR,'R');
                     ans.append(lenU,'U');
                     curx = g[i].x ,cury = g[i].y ;
                 }
                 else{
                     if(g[i].x < curx || g[i].y < cury){
                         cout<<"NO"<<endl;
                         f = ;
                         break;
                     }
                     int lenR = g[i].x - curx;
                     int lenU = g[i].y - cury;
                     ans.append(lenR,'R');
                     ans.append(lenU,'U');
                     curx = g[i].x ,cury = g[i].y ;
                 }
             }
             if(f == ) continue;
             cout<<"YES"<<endl;
             cout<<ans<<endl;
         }
         return ;
     }

C. Product of Three Numbers

题意：求不同的三个数a、b、c，使得a*b*c = n

思路：自己的做法有点复杂，用唯一分解定理做，枚举n的质因子，用质因子去组合成a，b，c，最后判断。

 #include<iostream>
 #include<vector>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<queue>
 #include<cstdio>
 #include<map>
 #include<set>
 #include<stack>
 #include<unordered_map>
 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long ll;
 void solve(){
     int n;
     cin>>n;
     int tn = n;
     set<int> s;
     int a,b;
     int t = ;
     for(int i = ;i*i<=n;i++){
         while(n%i == ){//枚举质因子
             n/=i;
             t = t*i;
             if(s.count(i) ==  ){
                 s.insert(i);
                 t = ;
             }
             if(s.count(t) ==  && t!=){
                 s.insert(t);
                 t = ;
             }
             if(s.size() == ){
                 set<int>::iterator iter = s.begin();
                 int x=*iter;
                 iter++;
                 x*=*iter;
                 if(s.count(tn/x) ==  && tn/x!=) {
                     s.insert(tn/x);
                     break;
                 }

             }
             if(s.size()>=) {
                 break;
             }
         }
         if(s.size()>=) break;
     }
     if(s.size()>=){
         cout<<"YES"<<endl;
         set<int>::iterator iter = s.begin();
         while(iter!=s.end()){
             cout<<*iter<<" ";
             iter++;
         }
     }
     else{
         cout<<"NO"<<endl;
     }
 }
 int main(){
     int t;
     cin>>t;
     while(t--){
         solve();
     }
     return ;
 }

D. MEX maximizing

题意：一个空数组，一个x值，有q次询问，每次询问向数组插入一个值，数组中所有的值可以任意增加n*x倍，减少n*x被，每次询问输出不包含在数组中最小的正整数值。

思路：一道思维题。每次询问时，把插入的值对x取余，设其为y，意为x可以转移成y，每次记录可以转移到y的数字个数，每次需要y时就查询，这样贪心地进行下去即可，时间复杂度O(n)级别。

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn = 4e5+;
 int v[maxn];
 int q,x;
 int main(){
     scanf("%d%d",&q,&x);
     int mex = ;
     while(q--){
         int y;scanf("%d",&y);
         if((y%x)!=(mex%x)) v[y%x]++;//当前如果不需要 就先记录下来(y%x)的个数
         else{
             mex++;//否则就消耗掉
             while(){
                 if(v[mex%x]) v[mex%x]--,mex++;//查询目前所需要的，如果有就消耗一次，再令mex++
                 else break;
             }
         }
         printf("%d\n",mex);
     }
     return ;
 }

E. Obtain a Permutation

题意：一个n×m的矩阵，矩阵元素的总个数不会超过2e5，有两种操作，1.改变矩阵中任意一元素的值 2.令矩阵的一列所有元素向上移动一格。 求矩阵所有元素恢复成最初位置所需要的最少操作次数

思路：操作只与列有关，贪心地去枚举每一列。扫描一列地的元素，开一个cnt数组，首先判断一下这个元素是否属于该列，如果属于该列，那么记录他恢复到原有位置需要向上移动多少次，假设需要i次，那么让cnt[i] ++，这样扫描完一列之后，再去找该列恢复原有序列的最小操作次数，ans = min(ans，i+n-cnt[i] )，i是该列所有元素移动次数，n是该列元素的个数，n-cnt[i]就是通过向上移动i次，不能到原有位置的元素，这样只能用操作1来实现了。

 #include<bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;
 int n,m;
 int main(){
     scanf("%d%d",&n,&m);
     int g[n][m];
     for(int i = ;i<n;i++){
         for(int j = ;j<m;j++){
             scanf("%d",&g[i][j]);
         }
     }
     int ans = ;
     for(int i = ;i<m;i++){
         vector<int> cnt(n);
         for(int j = ;j<n;j++) cnt[j] = ;//初始化cnt数组
         for(int j = ;j<n;j++){
             if((g[j][i]-)%m == i && g[j][i]<=m*n){//如果该元素属于这一列
                 int h = (g[j][i]-)/m ;//计算原有的位置
                 int dif = j - h;//计算需要向上移动的次数
                 if(dif<) dif+=n;
                 cnt[dif]++;//记录+1
             }
         }
         int t = inf;
         for(int j = ;j<n;j++) t = min(t,j+n-cnt[j]);//找出该列元素回到原有位置需要的最少操作次数
         ans+=t;//每一列操作次数都加和
     }
     printf("%d",ans);
     return ;
 }

F. Three Paths on a Tree

题意：给出一无权棵树，在树中找到三个结点a,b,c使得a到b到c路径距离最长，如果a到b的路径和a到c的路径有重复，重复的部分不做计算。

思路：首先树中两点之间最远的距离是树的直径，那么可以用bfs求出树的直径，直径两个端点设为a和b，再用bfs求出其他点到a和b的距离，最后枚举c点即可，这样是最优的，最终答案就等于（dis_ab+dis_bc+dis_ac) / 2。

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn = 2e5+;
 vector<int> G[maxn];
 int dis1[maxn],dis2[maxn],dis[maxn],v[maxn];
 int n,a,b,c,pos,disab,disac,disbc;
 void bfs(int cur){
     queue<int> q;
     q.push(cur);
     memset(v,,sizeof(v));
     memset(dis,,sizeof(dis));
     v[cur] = ;
     int p = cur,temp = ;
     while(!q.empty()){
         int now = q.front();
         q.pop();
         for(int i = ;i<G[now].size();i++){
             if(v[G[now][i]] == ){
                 v[G[now][i]] = ;
                 q.push(G[now][i]);
                 dis[G[now][i]] = dis[now] + ;//计算距离
                 if(dis[G[now][i]] > temp) p = G[now][i],temp = dis[G[now][i]];
             }
         }
     }
     pos = p;
 }

 int main(){
     scanf("%d",&n);
     int st;
     for(int i = ;i<n-;i++){
         int u,v;
         scanf("%d%d",&u,&v);
         st = u;
         G[u].push_back(v),G[v].push_back(u);
     }
     bfs();//枚举a
     a = pos ;
     bfs(a);//枚举b
     b = pos;
     int t = ;//两边bfs求出树的直径
     for(int i = ;i<maxn;i++){//求出其他点到a的距离
         dis1[i] = dis[i];
         if(dis1[i]>t) {
             b = i,t = dis1[i],disab = dis1[i];
         }
     }
     bfs(b);
     t = ;
     for(int i = ;i<maxn;i++){//求出其他点到b的距离
         dis2[i] = dis[i];
         if(dis1[i]>t) {
             t = dis2[i];
         }
     }
     for(int i = ;i<maxn;i++){
         if(dis1[i]+dis2[i] > disac + disbc && i!=a && i!=b){//枚举c点
             disac = dis1[i],disbc = dis2[i];
             c = i;
         }
     }
     printf("%d\n",(disac+disab+disbc)/);
     printf("%d %d %d",a,b,c);
     return ;
 }