CF练习记录

2018/5/6

Codeforces Round #478 (Div. 2) C

http://codeforces.com/contest/975/problem/C

Valhalla Siege

题意：n的士兵，每个士兵有一些生命值，有q次询问，每次询问从前向后造成k_i点贯穿伤害（生命值归零的士兵死去，后续士兵承受溢出伤害），问每次询问有几个士兵还活着。当所有士兵死去时，不继续造成溢出伤害并且所有士兵复活。

思路：二分搜索，对士兵生命值求前缀和，每次询问造成的伤害累计，记为s，用upper_bound来寻找前缀和中大于s的第一个人的位置i，n-i就是剩下的人数，如果剩下的人数为0（死完了），就全部复活，s清0。

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int MAX_N =  + ;
 ll x[MAX_N];
 ll sum[MAX_N];
 int main()
 {
     int i,n,q;
     cin >> n >> q;

     memset(sum,0x3f,sizeof(sum));
     for(i=;i<n;i++){
         cin >> x[i];
         if(i)
             sum[i]=sum[i-]+x[i];
         else
             sum[i]=x[i];
     }
     ll s=,tmp;
     for(i=;i<q;i++){
         cin >> tmp;
         s+=tmp;
         int index=upper_bound(sum,sum+MAX_N,s)-sum;
         if(n-index<=)
         {
             s=;
             index=;
         }
         cout << n-index << "\n";
     }
     return ;
 }

Codeforces Round #476 (Div. 2)

http://codeforces.com/contest/965/problem/C

D<=1000,因此可以简单枚举，每次最大一定是n/((i-1)*k+1) * i，但是有很多情况需要特判排除。

题解，https://www.cnblogs.com/AWCXV/p/8949119.html

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

 int main()
 {
     ios_base::sync_with_stdio(false);
     cin.tie();
     ll  n,k,M,D;
     cin  >> n >> k >> M >> D;
     ll ans=M;
     for(ll i=;i<=D;i++)
     {
         ll x=n/((i-)*k+);

         if(x==)break;
         if(x>M)x=M;
         if ((n/(k*x)+((n%(k*x)>=x?:)))!=i) continue;
         ans=max(ans, x*i);
     }
     cout << ans << "\n";

     return ;
 }

2018/5/17

http://codeforces.com/contest/984/problem/C

题意：给出p,q,b,求b进制下p/q是否为无穷小数。

思路：先用gcd将p/q化为真分数，再对于q和b：由于p和q互质，之后的过程就与p无关了。

由于是b进制，每进一位就相当于原小数*b，那么这个过程中就相当于q/gcd(q,b)。持续到q和gcd(q,b)其中一个为1即可。

一开始直接用快速幂……超时，%lld CF不能用CE。

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

 ll gcd(ll x,ll y){
     return y==?x:gcd(y,x%y);
 }

 int main()
 {
     ios::sync_with_stdio(false);
     cin.tie();
     ll p,q,b;
     int n;
     cin >> n;
     while(n--){
         cin >> p >> q >>b;
         ll x=p/gcd(p,q);
         ll y=q/gcd(p,q);
         ll cheek=gcd(y,b);
         while(y!=&&cheek!=){
             while(y%cheek==)y/=cheek;
             cheek=gcd(b,y);
         }
         if(y==)
             cout << "Finite\n";
         else
             cout << "Infinite\n";
     }
 }

2018/5/22

http://codeforces.com/contest/982

B

【题意】：

就是说有一辆公交车，有n排；

接下来n个数据代表n排的权值（每排只能坐2个人）；

然后接下来又2*n的数据

代表要坐入这辆公交车的人的类型。

1代表外向型，0代表内向型。

外向型：优先选择旁边有人的且权值最大的位置，如果没有的话，选择权值最大的位置。

内向型：优先选择没人的位置且权值最小的位置。

【思路】：

首先定义座位的属性：

状态：0代表旁边没人，1代表旁边有人。

第几排

权值

维护两个优先队列

优先队列0，用于维护旁边没人的座位，权值最小的排在最前面。

优先队列1，用于维护旁边有人的座位，权值最大的排在最前面。

一开始座位都没人，都存入队列0.

每次操作，从相应队列找最前面的位置，若队列0中找到座位，则将座位的状态改变存入队列1.

之后删除相应队列中的该座位。

输出即可。

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

 struct node{
     int state;
     int row;
     int pow;
     node(int s,int r,int p):state(s),row(r),pow(p){};
     node(){}
 };

 struct rule0{
     bool operator()(const node &a,const node &b){
         return a.pow<b.pow||a.pow==b.pow&&a.row<b.row;
     }
 };

 struct rule1{
     bool operator()(const node &a,const node &b){
         return a.pow>b.pow||a.pow==b.pow&&a.row<b.row;
     }
 };

 int main(){
     set<node,rule1> st1;
     set<node,rule0> st0;
     set<node,rule0>::iterator it0;
     set<node,rule1>::iterator it1;

     int n;
     cin >> n;
     int pow;
     for(int i=;i<n;i++){
         cin >> pow;
         node tmp(,i+,pow);
         st0.insert(tmp);
     }
     string people;
     cin >> people;
     for(int i=;people[i];i++){
         if(people[i]==''){
             it0=st0.begin();
             if(it0!=st0.end()){
                 node tmp=*it0;
                 st0.erase(it0);
                 tmp.state++;
                 st1.insert(tmp);
                 printf("%d%c",tmp.row,i==*n-?'\n':' ');
                 continue;
             }
             else{
                 it1=st1.begin();
                 node tmp=*it1;
                 st1.erase(it1);
                 printf("%d%c",tmp.row,i==*n-?'\n':' ');
                 continue;
             }

         }
         else {
             it1=st1.begin();
             if(it1==st1.end()){
                 it0=st0.begin();
                 node tmp=*it0;
                 st0.erase(it0);
                 tmp.state++;
                 st1.insert(tmp);
                 printf("%d%c",tmp.row,i==*n-?'\n':' ');
                 continue;
             }
             else{
                 node tmp=*it1;
                 st1.erase(it1);
                 printf("%d%c",tmp.row,i==*n-?'\n':' ');
                 continue;
             }
         }
     }
 }

C

题意：https://www.cnblogs.com/kickit/p/9054233.html

给出一棵树，问最多去掉多少条边之后，剩下的连通分量的size都是偶数。

思路：

如果本来就是奇数个点，那么无论去掉多少条边都不可能成立的。

如果是偶数个点，就进行一次dfs，假设一个点的父亲是u，儿子是v，那么可以去掉(u,v)的条件就是v及其子树有偶数个点，任何一条这样的边都是可以去掉的。

所以一边dfs，一边统计答案就可以了。

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int n;
 vector<int> v[];
 int ret;
 int dfs(int u,int f){
     int ans=;
     for(int i=;i<v[u].size();i++){
         if(v[u][i]!=f){
             int tmp=dfs(v[u][i],u);
             if(tmp%==)ret++;
             ans+=tmp;
         }
     }
     return ans;
 }

 int main(){
     cin >> n;
     if(n&){
         cout << - <<endl;
         return ;
     }

     int x,y;
     int start=-;
     for(int i=;i<n;i++){
         cin >>x >>y;
         v[x].push_back(y);
         v[y].push_back(x);
     }
     dfs(,-);
     cout << ret <<endl;
 }

479 C

阴险的陷阱题……

题意：

给一些数，范围从1到1e9，问是否存在一个数，使得正好有k个数小于等于这个数

思路：

很容易想到排序，前k个数一定是选入的，只要判断第k+1个数是否等于第k个数即可。

然而……WA了

问题在于k可以取0.

范围是从1开始的，所以还要判断这种情况下最小的数是否大于1，以上。

codeforces.com/contest/977

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

 int main(){
     int x[];
     int n,k;
     while(cin >> n >> k){
         memset(x,0x3f,sizeof(x));
         for(int i=;i<n;i++){
             cin >> x[i];
         }
         sort(x,x+n);
         if(k==){
             if(x[]>)
                 printf("1\n");
             else
                 printf("-1\n");
             continue;
         }
         else if(x[k]!=x[k-])
             printf("%d\n",x[k-]);
         else
             printf("-1\n");

     }
 }

Educational Codeforces Round 42

C. Make a Square

http://codeforces.com/contest/962/problem/C

题意：给一个无前导零的数，你可以删除任意多的数字，使得它成为一个无前导零的平方数……吗？若可以，输出最少操作数，若不可以，输出-1.

思路：

混乱……

开玩笑的，今天状态太差了，这么一道破水题卡了我一个小时，我还看题解了……

总之，题目很简单，暴力枚举，数据范围2e9，枚举所有可能情况最多也就1024种情况，每种情况判断是否无前导零、是否为平方数（开根号平方等于本身）即可。

一开始zz想用ac自动机被卡、情况0未考虑被卡、前导零未考虑被卡……

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <string>
 #include <iostream>
 #include <math.h>
 using namespace std;

 int main()
 {
     int i,j,tmp;
     string t;
     cin >> t;
     int flag=,ans=;
     for(i=;i<(<<t.size());i++){
         tmp=i;
         int s=;
         j=;
         int num=;
         while(tmp>){
             if( !(!s&&t[j]=='') && (tmp&) ){
                 s=s*+t[j]-'';
                 num++;
             }
             j++;
             tmp>>=;
         }
         if(s&&(int)sqrt(s)*(int)sqrt(s)==s ){
             ans=max(ans,num);
             flag=;
         }
     }
     if(!flag){
         printf("-1\n");
     }
     else
         printf("%d\n",t.size()-ans);
     return ;
 }

5.24

http://codeforces.com/contest/985

越写越觉得自己是zz……

1.水题暴力即可，没考虑排序……

 #include <iostream>
 #include <bits/stdc++.h>
 using namespace std;
 int abs(int x){
     return x >  ? x : -x;
 }

 int main()
 {
     int n;
     int x[];
     cin >> n ;
     for(int i=;*i<n;i++){
         cin >> x[i];
     }
     sort(x,x+n/);
     int a=,b=;
     for(int i=;*i<n;i++){
         a+=abs(*i+-x[i]);
     }
     for(int i=;*i<n;i++){
         b+=abs(*i+-x[i]);
     }
     printf("%d\n",min(a,b));
     return ;
 }

2.水题

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

 int x[]={};
 string a[];
 int main()
 {
     int n,m,flag,yes=;
     cin >> n  >> m;
     for(int i=;i<n;i++){
         cin >> a[i];
         for(int j=;a[i][j];j++){
             if(a[i][j]=='')
                 x[j]++;
         }
     }
     for(int i=;i<n;i++){
         flag=;
         for(int j=;a[i][j];j++){
             if(a[i][j]==''&&x[j]<){
                 flag=;
             }
         }
         if(flag){
             yes=;
             printf("YES\n");
             break;
         }
     }
     if(!yes){
         printf("NO\n");
     }
     return ;
 }

3.贪心

确定能选的范围，之后每次选能选到的最大的。

爆int，用long long

 #include <iostream>
 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 ll x[];
 int main()
 {
     int n,k,l;
     cin >> n >> k >> l;
     for(int i=;i<n*k;i++){
         cin >> x[i];
     }
     sort(x,x+n*k);
     int index=upper_bound(x,x+n*k,x[]+l)-x;
 //    cout << index <<endl;
     if(index<n){
         printf("0\n");
         return ;
     }
     ll sum=;
 //    for(int i=0;i<n*k;i++)
 //        printf("%d\t",x[i]);

     for(int i=;n&&i<index;){
         sum+=x[i];
         i+=min(k,max(index-i-n+,));
         n--;
 //        printf("index-i-n+1:%d\n",index-i-n+1);
 //        printf("i:%d\n",i);
     }
     cout << sum << endl;
     return ;
 }

5.25

1.水题，注意n==0的情况即可

 #include <iostream>

 using namespace std;

 int main()
 {
     long long n;
     cin >> n;
     if(!n){
         cout <<  << endl;
         return ;
     }
     n++;

     if(n%==)
         cout <<n/ <<endl;
     else
         cout << n << endl;
     return ;
 }

2.贪心，注意特殊情况，全部相同字符情况n==1时减少一位

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

 int main()
 {
     string a[];
     int num;
     cin >> num >> a[] >> a[] >> a[];
     int ch[][]={};
     for(int j=;j<;j++){

         for(int i=;a[j][i];i++){
             ch[j][ a[j][i] ]++;
             ch[j][]=max(ch[j][],ch[j][a[j][i]]);
         }
         if(num==&&ch[j][]==(int)a[j].size()){
             ch[j][]--;
             continue;
         }
         ch[j][]=min(ch[j][]+num,(int)a[j].size());

     }
     int maxn=max(max(ch[][],ch[][]),ch[][]);
     if(maxn==ch[][]&&maxn==ch[][]||
        maxn==ch[][]&&maxn==ch[][]||
        maxn==ch[][]&&maxn==ch[][])
         cout << "Draw\n";
     else if(maxn==ch[][])
         cout << "Kuro\n";
     else if(maxn==ch[][])
         cout << "Shiro\n";
     else if(maxn==ch[][])
         cout << "Katie\n";

     return ;
 }