Codeforces Round #279 (Div. 2) 解题报告 A.B.C.D.E

A - Team Olympiad

贪心水题。。都从第一个开始取即可。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
int a[6000], b[6000];
int main()
{
    int n, x, y, z, ans, i, j;
    while(scanf("%d",&n)!=EOF)
    {
        x=y=z=0;
        for(i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        memset(b,0,sizeof(b));
        for(i=0;i<n;i++)
        {
            if(a[i]==1)
            {
                x++;
                b[i]=x;
            }
            else if(a[i]==2)
            {
                y++;
                b[i]=y;
            }
            else if(a[i]==3)
            {
                z++;
                b[i]=z;
            }
        }
        ans=min(x,min(y,z));
        printf("%d\n",ans);
        for(i=1;i<=ans;i++)
        {
            for(j=0;j<n;j++)
            {
                if(b[j]==i)
                {
                    printf("%d ",j+1);
                }
            }
            puts("");
        }
    }
    return 0;
}

B - Queue

通过用数组记录下一个位置,分别把偶数位置与奇数位置上的填满。

偶数位置上一定是从0开始的,奇数位置一定是从一个没有出度只有入度的一个数开始的。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
int next[1100000], a[1100000], out[1100000];
struct node
{
    int u, v;
}fei[1100000];
int main()
{
    int n, i, j, u, v, cnt, pos;
    while(scanf("%d",&n)!=EOF)
    {
        memset(next,-1,sizeof(next));
        memset(out,0,sizeof(out));
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&fei[i].u, &fei[i].v);
            next[fei[i].u]=fei[i].v;
            out[fei[i].v]++;
        }
        cnt=1;
        for(i=0;i!=-1;i=next[i])
        {
            if(cnt!=1&&!i) break;
            a[cnt]=next[i];
            cnt+=2;
        }
        cnt=0;
        for(i=0;i<n;i++)
        {
            if(!out[fei[i].u])
            {
                pos=fei[i].u;
                break;
            }
        }
        a[0]=pos;
        cnt=2;
        for(i=pos;i!=-1;i=next[i])
        {
            a[cnt]=next[i];
            cnt+=2;
        }
        for(i=0;i<n;i++)
        {
            printf("%d ",a[i]);
        }
    }
    return 0;
}

C - Hacking Cypher

分别从前和后扫一遍记录下能整除的位置。从前往后的很好处理。

至于从后往前的,对于第k位来说,可以先预处理10^k对b的余数和以及前k位对b的余数,然后,后几位=总数-前k位表示的数*10^k。所以只要满足总数%b==(前k位表示的数%b)*(10^k%b)%b,就标明后几位表示的数可以整除b。

这样就可以在O(n)的复杂度内完成了。

表示自己真是弱渣。。看别人都一会儿就做出来了。。自己却想了半个小时才想出来。。。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
int a[1100000], b[1100000], c[1100000], d[1100000];
char s[1100000];
int main()
{
    int aa, bb, i, x, len, pos, flag=0, y;
    gets(s);
    scanf("%d%d",&aa,&bb);
    memset(a,0,sizeof(a));
    memset(d,0,sizeof(d));
    x=1;
    c[1]=1%bb;
    for(i=2;i<=1000000;i++)
    {
        x=x*10%bb;
        c[i]=x;
    }
    len=strlen(s);
    x=0;
    y=0;
    for(i=0;i<len;i++)
    {
        x=x*10+s[i]-'0';
        x%=aa;
        //printf("%d\n",x);
        if(x==0)
            a[i]=1;
        y=y*10+s[i]-'0';
        y%=bb;
        b[i]=y;
    }
    //printf("%d\n",y);
    for(i=0;i<len;i++)
    {
        if((LL)b[i]*c[len-i]%bb==(LL)y)
        {
            d[i]=1;
        }
    }
    for(i=0;i<len-1;i++)
    {
        if(a[i]&&d[i]&&s[i+1]!='0')
        {
            pos=i;
            flag=1;
            break;
        }
    }
    if(!flag)
        puts("NO");
    else
    {
        puts("YES");
        for(i=0;i<=pos;i++)
        {
            printf("%c",s[i]);
        }
        puts("");
        for(i=pos+1;i<len;i++)
        {
            printf("%c",s[i]);
        }
    }
    return 0;
}

D - Chocolate

如果最终的面积相等的话,那么2的因子数与3的因子数一定相等。所以可以先求出2的因子数与3的因子数。然后这时候我们可以有两种操作:消去一个2或者把一个3变成2.所以这时候先把3较大的一方变成2,使得剩下的3相等,然后再消去2的因子数较大的一方使得相等。然后在判断这时候双方面积相等即可。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64

int main()
{
    int a1, b1, a2, b2, x2, x3, y2, y3, ans, m1, m2, n1, n2;
    while(scanf("%d%d%d%d",&a1,&b1,&a2,&b2)!=EOF)
    {
        m1=a1;
        m2=a2;
        n1=b1;
        n2=b2;
        x2=x3=y2=y3=0;
        while(!(a1%2)||!(a1%3))
        {
            if(a1%2==0)
            {
                x2++;
                a1/=2;
            }
            if(a1%3==0)
            {
                x3++;
                a1/=3;
            }
        }
        while(!(b1%2)||!(b1%3))
        {
            if(b1%2==0)
            {
                x2++;
                b1/=2;
            }
            if(b1%3==0)
            {
                x3++;
                b1/=3;
            }
        }
        while(!(a2%2)||!(a2%3))
        {
            if(a2%2==0)
            {
                y2++;
                a2/=2;
            }
            if(a2%3==0)
            {
                y3++;
                a2/=3;
            }
        }
        while(!(b2%2)||!(b2%3))
        {
            if(b2%2==0)
            {
                y2++;
                b2/=2;
            }
            if(b2%3==0)
            {
                y3++;
                b2/=3;
            }
        }
        if(x3>=y3)
        {
            x2+=x3-y3;
            ans=x3-y3;
            for(int i=0; i<x3-y3; i++)
            {
                if(m1%3==0)  m1=m1/3*2;
                else  n1=n1/3*2;
            }
        }
        else
        {
            y2+=y3-x3;
            ans=y3-x3;
            for(int i=0; i<y3-x3; i++)
            {
                if(m2%3==0) m2=m2/3*2;
                else n2=n2/3*2;
            }
        }
        ans+=abs(x2-y2);
        if(x2>=y2)
        {
            for(int i=0; i<x2-y2; i++)
            {
                if(m1%2==0) m1/=2;
                else n1/=2;
            }
        }
        else
        {
            for(int i=0; i<y2-x2; i++)
            {
                if(m2%2==0) m2/=2;
                else n2/=2;
            }
        }
        if((LL)m1*n1!=(LL)m2*n2)
            puts("-1");
        else
        {
            printf("%d\n",ans);
            printf("%d %d\n%d %d\n",m1,n1,m2,n2);
        }
    }
    return 0;
}

E - Restoring Increasing Sequence

贪心+模拟。

从前开始,保证每个数都是大于前面那个数的最小可能值。当有一个不可能的时候。就表明不可能存在。

代码写的太挫。。。。。

代码如下:

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
char s[110000][10];
int main()
{
    int n, i, x, y, z, len, l, flag, j, k, pos;
    while(scanf("%d",&n)!=EOF)
    {
        getchar();
        flag=0;
        for(i=1; i<=n; i++)
        {
            gets(s[i]);
        }
        z=0;
        l=1;
        s[0][0]='0';
        for(i=1; i<=n; i++)
        {
            len=strlen(s[i]);
            if(len<l)
            {
                flag=1;
                break;
            }
            else if(len>l)
            {
                for(j=0; j<len; j++)
                {
                    if(s[i][j]=='?')
                    {
                        if(j==0)
                            s[i][j]='1';
                        else
                            s[i][j]='0';
                    }
                }
            }
            else
            {
                int f=0, ff=0;
                for(j=0; j<len; j++)
                {
                    if(s[i][j]!='?')
                    {
                        if(s[i][j]>s[i-1][j])
                        {
                            ff=1;
                            for(k=0; k<j; k++)
                            {
                                s[i][k]=s[i-1][k];
                            }
                            for(k=j+1; k<len; k++)
                            {
                                if(s[i][k]=='?')
                                {
                                    s[i][k]='0';
                                }
                            }
                            break;
                        }
                        else if(s[i][j]<s[i-1][j])
                        {
                            ff=1;
                            if(!f)
                            {
                                flag=1;
                                break;
                            }
                            else
                            {
                                pos=-1;
                                for(k=j-1; k>=0; k--)
                                {
                                    if(s[i][k]=='?'&&s[i-1][k]!='9')
                                    {
                                        s[i][k]=s[i-1][k]+1;
                                        pos=k;
                                        break;
                                    }
                                }
                                if(pos==-1)
                                {
                                    flag=1;
                                }
                                else
                                {
                                    for(k=0; k<pos; k++)
                                    {
                                        s[i][k]=s[i-1][k];
                                    }
                                    for(k=pos+1; k<len; k++)
                                    {
                                        if(s[i][k]=='?')
                                        {
                                            s[i][k]='0';
                                        }
                                    }
                                }
                            }
                            break;
                        }
                    }
                    else
                        f=1;
                }
                if(ff==0)
                {
                    pos=-1;
                    for(j=len-1;j>=0;j--)
                    {
                        if(s[i][j]=='?'&&s[i-1][j]!='9')
                        {
                            s[i][j]=s[i-1][j]+1;
                            pos=j;
                            break;
                        }
                    }
                    if(pos==-1)
                    {
                        flag=1;
                        break;
                    }
                    for(j=0;j<pos;j++)
                    {
                        s[i][j]=s[i-1][j];
                    }
                    for(j=pos+1;j<len;j++)
                    {
                        if(s[i][j]=='?')
                            s[i][j]='0';
                    }
                }
            }
            l=len;
        }
        if(flag) puts("NO");
        else
        {
            puts("YES");
            for(i=1; i<=n; i++)
            {
                printf("%s\n",s[i]);
            }
        }
    }
    return 0;
}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值