2017acm福建省赛FZU 2278 YYS

最新推荐文章于 2023-01-13 17:40:10 发布
最新推荐文章于 2023-01-13 17:40:10 发布
阅读量1.4k 收藏
点赞数
分类专栏： 模板

Problem 2278 YYS

Accept: 31    Submit: 94
Time Limit: 1000 mSec    Memory Limit : 262144 KB

Problem Description

Yinyangshi is a famous RPG game on mobile phones.

Kim enjoys collecting cards in this game. Suppose there are n kinds of cards. If you want to get a new card, you need to pay W coins to draw a card. Each time you can only draw one card, all the cards appear randomly with same probability 1/n. Kim can get 1 coin each day. Suppose Kim has 0 coin and no cards on day 0. Every W days, Kim can draw a card with W coins. In this problem ,we define W=(n-1)!.

Now Kim wants to know the expected days he can collect all the n kinds of cards.

Input

The first line an integer T(1 ≤ T ≤ 10). There are T test cases.

The next T lines, each line an integer n. (1≤n≤3000)

Output

For each n, output the expected days to collect all the n kinds of cards, rounded to one decimal place.

Sample Input

4
1
2
5
9

Sample Output

1.0
3.0
274.0
1026576.0

Source

第八届福建省大学生程序设计竞赛-重现赛（感谢承办方厦门理工学院）
http://acm.fzu.edu.cn/problem.php?pid=2278
看完题目还是知道做的 一个东西中奖几率是 3/4 讲道理就得抽4/3次 才中一次

所以这个问题就是求 Σn！/i（1<=i<=n） 其实这个数肯定是整数 保留一位小数就是糊弄人的

n等于3000 爆炸 大数相乘 自己写了一个好无语 超时

下面 大神的 不敢模仿 500多行代码 

http://blog.csdn.net/mengxiang000000/article/details/75949074

#include <iostream>
#include <cstring>
using namespace std;
#define DIGIT   4      //四位隔开,即万进制
#define DEPTH   10000        //万进制
#define MAX     25100    //题目最大位数/4，要不大直接设为最大位数也行
typedef int bignum_t[MAX+1];
int read(bignum_t a,istream&is=cin)
{
    char buf[MAX*DIGIT+1],ch ;
    int i,j ;
    memset((void*)a,0,sizeof(bignum_t));
    if(!(is>>buf))return 0 ;
    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
    for(i=1;i<=a[0];i++)
    for(a[i]=0,j=0;j<DIGIT;j++)
    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;
    for(;!a[a[0]]&&a[0]>1;a[0]--);
    return 1 ;
}

void write(const bignum_t a,ostream&os=cout)
{
    int i,j ;
    for(os<<a[i=a[0]],i--;i;i--)
    for(j=DEPTH/10;j;j/=10)
    os<<a[i]/j%10 ;
}

int comp(const bignum_t a,const bignum_t b)
{
    int i ;
    if(a[0]!=b[0])
    return a[0]-b[0];
    for(i=a[0];i;i--)
    if(a[i]!=b[i])
    return a[i]-b[i];
    return 0 ;
}

int comp(const bignum_t a,const int b)
{
    int c[12]=
    {
        1
    }
    ;
    for(c[1]=b;c[c[0]]>=DEPTH;c[c[0]+1]=c[c[0]]/DEPTH,c[c[0]]%=DEPTH,c[0]++);
    return comp(a,c);
}

int comp(const bignum_t a,const int c,const int d,const bignum_t b)
{
    int i,t=0,O=-DEPTH*2 ;
    if(b[0]-a[0]<d&&c)
    return 1 ;
    for(i=b[0];i>d;i--)
    {
        t=t*DEPTH+a[i-d]*c-b[i];
        if(t>0)return 1 ;
        if(t<O)return 0 ;
    }
    for(i=d;i;i--)
    {
        t=t*DEPTH-b[i];
        if(t>0)return 1 ;
        if(t<O)return 0 ;
    }
    return t>0 ;
}
void add(bignum_t a,const bignum_t b)
{
    int i ;
    for(i=1;i<=b[0];i++)
    if((a[i]+=b[i])>=DEPTH)
    a[i]-=DEPTH,a[i+1]++;
    if(b[0]>=a[0])
    a[0]=b[0];
    else
    for(;a[i]>=DEPTH&&i<a[0];a[i]-=DEPTH,i++,a[i]++);
    a[0]+=(a[a[0]+1]>0);
}
void add(bignum_t a,const int b)
{
    int i=1 ;
    for(a[1]+=b;a[i]>=DEPTH&&i<a[0];a[i+1]+=a[i]/DEPTH,a[i]%=DEPTH,i++);
    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
}
void sub(bignum_t a,const bignum_t b)
{
    int i ;
    for(i=1;i<=b[0];i++)
    if((a[i]-=b[i])<0)
    a[i+1]--,a[i]+=DEPTH ;
    for(;a[i]<0;a[i]+=DEPTH,i++,a[i]--);
    for(;!a[a[0]]&&a[0]>1;a[0]--);
}
void sub(bignum_t a,const int b)
{
    int i=1 ;
    for(a[1]-=b;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
    for(;!a[a[0]]&&a[0]>1;a[0]--);
}

void sub(bignum_t a,const bignum_t b,const int c,const int d)
{
    int i,O=b[0]+d ;
    for(i=1+d;i<=O;i++)
    if((a[i]-=b[i-d]*c)<0)
    a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH ;
    for(;a[i]<0;a[i+1]+=(a[i]-DEPTH+1)/DEPTH,a[i]-=(a[i]-DEPTH+1)/DEPTH*DEPTH,i++);
    for(;!a[a[0]]&&a[0]>1;a[0]--);
}
void mul(bignum_t c,const bignum_t a,const bignum_t b)
{
    int i,j ;
    memset((void*)c,0,sizeof(bignum_t));
    for(c[0]=a[0]+b[0]-1,i=1;i<=a[0];i++)
    for(j=1;j<=b[0];j++)
    if((c[i+j-1]+=a[i]*b[j])>=DEPTH)
    c[i+j]+=c[i+j-1]/DEPTH,c[i+j-1]%=DEPTH ;
    for(c[0]+=(c[c[0]+1]>0);!c[c[0]]&&c[0]>1;c[0]--);
}
void mul(bignum_t a,const int b)
{
    int i ;
    for(a[1]*=b,i=2;i<=a[0];i++)
    {
        a[i]*=b ;
        if(a[i-1]>=DEPTH)
        a[i]+=a[i-1]/DEPTH,a[i-1]%=DEPTH ;
    }
    for(;a[a[0]]>=DEPTH;a[a[0]+1]=a[a[0]]/DEPTH,a[a[0]]%=DEPTH,a[0]++);
    for(;!a[a[0]]&&a[0]>1;a[0]--);
}

void mul(bignum_t b,const bignum_t a,const int c,const int d)
{
    int i ;
    memset((void*)b,0,sizeof(bignum_t));
    for(b[0]=a[0]+d,i=d+1;i<=b[0];i++)
    if((b[i]+=a[i-d]*c)>=DEPTH)
    b[i+1]+=b[i]/DEPTH,b[i]%=DEPTH ;
    for(;b[b[0]+1];b[0]++,b[b[0]+1]=b[b[0]]/DEPTH,b[b[0]]%=DEPTH);
    for(;!b[b[0]]&&b[0]>1;b[0]--);
}
void div(bignum_t c,bignum_t a,const bignum_t b)
{
    int h,l,m,i ;
    memset((void*)c,0,sizeof(bignum_t));
    c[0]=(b[0]<a[0]+1)?(a[0]-b[0]+2):1 ;
    for(i=c[0];i;sub(a,b,c[i]=m,i-1),i--)
    for(h=DEPTH-1,l=0,m=(h+l+1)>>1;h>l;m=(h+l+1)>>1)
    if(comp(b,m,i-1,a))h=m-1 ;
    else l=m ;
    for(;!c[c[0]]&&c[0]>1;c[0]--);
    c[0]=c[0]>1?c[0]:1 ;
}

void div(bignum_t a,const int b,int&c)
{
    int i ;
    for(c=0,i=a[0];i;c=c*DEPTH+a[i],a[i]=c/b,c%=b,i--);
    for(;!a[a[0]]&&a[0]>1;a[0]--);
}
void sqrt(bignum_t b,bignum_t a)
{
    int h,l,m,i ;
    memset((void*)b,0,sizeof(bignum_t));
    for(i=b[0]=(a[0]+1)>>1;i;sub(a,b,m,i-1),b[i]+=m,i--)
    for(h=DEPTH-1,l=0,b[i]=m=(h+l+1)>>1;h>l;b[i]=m=(h+l+1)>>1)
    if(comp(b,m,i-1,a))h=m-1 ;
    else l=m ;
    for(;!b[b[0]]&&b[0]>1;b[0]--);
    for(i=1;i<=b[0];b[i++]>>=1);
}
int digit(const bignum_t a,const int b)
{
    int i,ret ;
    for(ret=a[(b-1)/DIGIT+1],i=(b-1)%DIGIT;i;ret/=10,i--);
    return ret%10 ;
}
#define SGN(x) ((x)>0?1:((x)<0?-1:0))
#define ABS(x) ((x)>0?(x):-(x))

int read(bignum_t a,int&sgn,istream&is=cin)
{
    char str[MAX*DIGIT+2],ch,*buf ;
    int i,j ;
    memset((void*)a,0,sizeof(bignum_t));
    if(!(is>>str))return 0 ;
    buf=str,sgn=1 ;
    if(*buf=='-')sgn=-1,buf++;
    for(a[0]=strlen(buf),i=a[0]/2-1;i>=0;i--)
    ch=buf[i],buf[i]=buf[a[0]-1-i],buf[a[0]-1-i]=ch ;
    for(a[0]=(a[0]+DIGIT-1)/DIGIT,j=strlen(buf);j<a[0]*DIGIT;buf[j++]='0');
    for(i=1;i<=a[0];i++)
    for(a[i]=0,j=0;j<DIGIT;j++)
    a[i]=a[i]*10+buf[i*DIGIT-1-j]-'0' ;
    for(;!a[a[0]]&&a[0]>1;a[0]--);
    if(a[0]==1&&!a[1])sgn=0 ;
    return 1 ;
}
struct bignum
{
    bignum_t num ;
    int sgn ;
    public :
    inline bignum()
    {
        memset(num,0,sizeof(bignum_t));
        num[0]=1 ;
        sgn=0 ;
    }
    inline int operator!()
    {
        return num[0]==1&&!num[1];
    }
    inline bignum&operator=(const bignum&a)
    {
        memcpy(num,a.num,sizeof(bignum_t));
        sgn=a.sgn ;
        return*this ;
    }
    inline bignum&operator=(const int a)
    {
        memset(num,0,sizeof(bignum_t));
        num[0]=1 ;
        sgn=SGN (a);
        add(num,sgn*a);
        return*this ;
    }
    ;
    inline bignum&operator+=(const bignum&a)
    {
        if(sgn==a.sgn)add(num,a.num);
        else if
        (sgn&&a.sgn)
        {
            int ret=comp(num,a.num);
            if(ret>0)sub(num,a.num);
            else if(ret<0)
            {
                bignum_t t ;
                memcpy(t,num,sizeof(bignum_t));
                memcpy(num,a.num,sizeof(bignum_t));
                sub (num,t);
                sgn=a.sgn ;
            }
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
        }
        else if(!sgn)
            memcpy(num,a.num,sizeof(bignum_t)),sgn=a.sgn ;
        return*this ;
    }
    inline bignum&operator+=(const int a)
    {
        if(sgn*a>0)add(num,ABS(a));
        else if(sgn&&a)
        {
            int  ret=comp(num,ABS(a));
            if(ret>0)sub(num,ABS(a));
            else if(ret<0)
            {
                bignum_t t ;
                memcpy(t,num,sizeof(bignum_t));
                memset(num,0,sizeof(bignum_t));
                num[0]=1 ;
                add(num,ABS (a));
                sgn=-sgn ;
                sub(num,t);
            }
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
        }
        else if
            (!sgn)sgn=SGN(a),add(num,ABS(a));
        return*this ;
    }
    inline bignum operator+(const bignum&a)
    {
        bignum ret ;
        memcpy(ret.num,num,sizeof (bignum_t));
        ret.sgn=sgn ;
        ret+=a ;
        return ret ;
    }
    inline bignum operator+(const int a)
    {
        bignum ret ;
        memcpy(ret.num,num,sizeof (bignum_t));
        ret.sgn=sgn ;
        ret+=a ;
        return ret ;
    }
    inline bignum&operator-=(const bignum&a)
    {
        if(sgn*a.sgn<0)add(num,a.num);
        else if
        (sgn&&a.sgn)
        {
            int ret=comp(num,a.num);
            if(ret>0)sub(num,a.num);
            else if(ret<0)
            {
                bignum_t t ;
                memcpy(t,num,sizeof(bignum_t));
                memcpy(num,a.num,sizeof(bignum_t));
                sub(num,t);
                sgn=-sgn ;
            }
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
        }
        else if(!sgn)add (num,a.num),sgn=-a.sgn ;
        return*this ;
    }
    inline bignum&operator-=(const int a)
    {
        if(sgn*a<0)add(num,ABS(a));
        else if(sgn&&a)
        {
            int  ret=comp(num,ABS(a));
            if(ret>0)sub(num,ABS(a));
            else if(ret<0)
            {
                bignum_t t ;
                memcpy(t,num,sizeof(bignum_t));
                memset(num,0,sizeof(bignum_t));
                num[0]=1 ;
                add(num,ABS(a));
                sub(num,t);
                sgn=-sgn ;
            }
            else memset(num,0,sizeof(bignum_t)),num[0]=1,sgn=0 ;
        }
        else if
            (!sgn)sgn=-SGN(a),add(num,ABS(a));
        return*this ;
    }
    inline bignum operator-(const bignum&a)
    {
        bignum ret ;
        memcpy(ret.num,num,sizeof(bignum_t));
        ret.sgn=sgn ;
        ret-=a ;
        return ret ;
    }
    inline bignum operator-(const int a)
    {
        bignum ret ;
        memcpy(ret.num,num,sizeof(bignum_t));
        ret.sgn=sgn ;
        ret-=a ;
        return ret ;
    }
    inline bignum&operator*=(const bignum&a)
    {
        bignum_t t ;
        mul(t,num,a.num);
        memcpy(num,t,sizeof(bignum_t));
        sgn*=a.sgn ;
        return*this ;
    }
    inline bignum&operator*=(const int a)
    {
        mul(num,ABS(a));
        sgn*=SGN(a);
        return*this ;
    }
    inline bignum operator*(const bignum&a)
    {
        bignum ret ;
        mul(ret.num,num,a.num);
        ret.sgn=sgn*a.sgn ;
        return ret ;
    }
    inline bignum operator*(const int a)
    {
        bignum ret ;
        memcpy(ret.num,num,sizeof (bignum_t));
        mul(ret.num,ABS(a));
        ret.sgn=sgn*SGN(a);
        return ret ;
    }
    inline bignum&operator/=(const bignum&a)
    {
        bignum_t t ;
        div(t,num,a.num);
        memcpy (num,t,sizeof(bignum_t));
        sgn=(num[0]==1&&!num[1])?0:sgn*a.sgn ;
        return*this ;
    }
    inline bignum&operator/=(const int a)
    {
        int t ;
        div(num,ABS(a),t);
        sgn=(num[0]==1&&!num [1])?0:sgn*SGN(a);
        return*this ;
    }
    inline bignum operator/(const bignum&a)
    {
        bignum ret ;
        bignum_t t ;
        memcpy(t,num,sizeof(bignum_t));
        div(ret.num,t,a.num);
        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*a.sgn ;
        return ret ;
    }
    inline bignum operator/(const int a)
    {
        bignum ret ;
        int t ;
        memcpy(ret.num,num,sizeof(bignum_t));
        div(ret.num,ABS(a),t);
        ret.sgn=(ret.num[0]==1&&!ret.num[1])?0:sgn*SGN(a);
        return ret ;
    }
    inline bignum&operator%=(const bignum&a)
    {
        bignum_t t ;
        div(t,num,a.num);
        if(num[0]==1&&!num[1])sgn=0 ;
        return*this ;
    }
    inline int operator%=(const int a)
    {
        int t ;
        div(num,ABS(a),t);
        memset(num,0,sizeof (bignum_t));
        num[0]=1 ;
        add(num,t);
        return t ;
    }
    inline bignum operator%(const bignum&a)
    {
        bignum ret ;
        bignum_t t ;
        memcpy(ret.num,num,sizeof(bignum_t));
        div(t,ret.num,a.num);
        ret.sgn=(ret.num[0]==1&&!ret.num [1])?0:sgn ;
        return ret ;
    }
    inline int operator%(const int a)
    {
        bignum ret ;
        int t ;
        memcpy(ret.num,num,sizeof(bignum_t));
        div(ret.num,ABS(a),t);
        memset(ret.num,0,sizeof(bignum_t));
        ret.num[0]=1 ;
        add(ret.num,t);
        return t ;
    }
    inline bignum&operator++()
    {
        *this+=1 ;
        return*this ;
    }
    inline bignum&operator--()
    {
        *this-=1 ;
        return*this ;
    }
    ;
    inline int operator>(const bignum&a)
    {
        return sgn>0?(a.sgn>0?comp(num,a.num)>0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<0:0):a.sgn<0);
    }
    inline int operator>(const int a)
    {
        return sgn>0?(a>0?comp(num,a)>0:1):(sgn<0?(a<0?comp(num,-a)<0:0):a<0);
    }
    inline int operator>=(const bignum&a)
    {
        return sgn>0?(a.sgn>0?comp(num,a.num)>=0:1):(sgn<0?(a.sgn<0?comp(num,a.num)<=0:0):a.sgn<=0);
    }
    inline int operator>=(const int a)
    {
        return sgn>0?(a>0?comp(num,a)>=0:1):(sgn<0?(a<0?comp(num,-a)<=0:0):a<=0);
    }
    inline int operator<(const bignum&a)
    {
        return sgn<0?(a.sgn<0?comp(num,a.num)>0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<0:0):a.sgn>0);
    }
    inline int operator<(const int a)
    {
        return sgn<0?(a<0?comp(num,-a)>0:1):(sgn>0?(a>0?comp(num,a)<0:0):a>0);
    }
    inline int operator<=(const bignum&a)
    {
        return sgn<0?(a.sgn<0?comp(num,a.num)>=0:1):(sgn>0?(a.sgn>0?comp(num,a.num)<=0:0):a.sgn>=0);
    }
    inline int operator<=(const int a)
    {
        return sgn<0?(a<0?comp(num,-a)>=0:1):
        (sgn>0?(a>0?comp(num,a)<=0:0):a>=0);
    }
    inline int operator==(const bignum&a)
    {
        return(sgn==a.sgn)?!comp(num,a.num):0 ;
    }
    inline int operator==(const int a)
    {
        return(sgn*a>=0)?!comp(num,ABS(a)):0 ;
    }
    inline int operator!=(const bignum&a)
    {
        return(sgn==a.sgn)?comp(num,a.num):1 ;
    }
    inline int operator!=(const int a)
    {
        return(sgn*a>=0)?comp(num,ABS(a)):1 ;
    }
    inline int operator[](const int a)
    {
        return digit(num,a);
    }
    friend inline istream&operator>>(istream&is,bignum&a)
    {
        read(a.num,a.sgn,is);
        return  is ;
    }
    friend inline ostream&operator<<(ostream&os,const bignum&a)
    {
        if(a.sgn<0)
            os<<'-' ;
        write(a.num,os);
        return os ;
    }
};
int main()
{
    int  t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        bignum jiecheng,ans;
        jiecheng+=1;
        for(int i=1;i<=n;i++)
        {
            jiecheng*=i;
        }
        for(int i=1;i<=n;i++)
        {
            ans=ans+jiecheng/i;
        }
        cout<<ans<<".0"<<endl;
    }
}


没有灵魂的程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zjp2018_problems_ACM省赛题目_浙江2018年_
10-03
浙江省2018年ACM省赛题目，15届ACM省赛题目
厦门理工学院oj1705
m0_73211704的博客
12-12 238
解题思路：要求先输入一个整数代表复习科目，对我们而言其实就是要输入的行数，所以可以先用scanf获取一个a，然后用for循环连续获取a行数字，然后接下来就是直接然后前一个数字乘60后与后一个数字相加，重复a次，获得总时间。从第二行开始的N行，每行有两个整型数字，代表复习第N门科目需要耗费的H小时(1 ≤ N ≤ 23)，M分钟(0 ≤ N ≤ 59)。复习时间=2小时40分钟+1小时50分钟+3小时55分钟=6小时145分钟=360分钟+145分钟=505分钟。入一个整型数字，代表需要复习的科目数量N。
厦门理工学院oj1753
m0_73211704的博客
12-13 323
已知：1+2+3+ …+ 100 = 5050，请找出两个不相邻（至少被两个数字间隔开）的加号变成乘号，使计算结果变为8260。比如，把5和57两个位置的加号变成乘号，即可满足：1+2+3+…+57*58+59+…+100 = 8260（注意：乘法优先级高于加法）。请聪明的你找出所有可能的位置。解题思路：分别取俩次俩个相邻数字然后相乘，那么求和就是5050减去不加起来的了，加上加起来的。每行两个整数（空格间隔）,两个整数表示乘号的两个位置（对于示例，就是5 57）按第一个位置的值从小到大顺序输出结果。
ACM 福建省省赛 D题 Game
请赐教
07-23 789
滴，集训第六天打卡。 今天做的是福建省省赛的重现赛... 可以说是打铁了一下午... 省赛的题目都很灵活啊..dota...lol..yys... A了三题..感觉最后两题是可以做的但是没写出来... 这里贴D题 Game Alice and Bob is playing a game. Each of them has a number. Alice’s number is
厦门理工学院oj1729
m0_73211704的博客
12-14 202
辅导员老师根据疫情防控要求学生分批离校，如果是省内学生可以从2022年12月31日开始离校；解题思路：可以观察到将31减去现在的号数是无论如何都要做的，所以可以先写出这个，然后判断是否需要加上11月的天数或者加上外省的一天。输入12 30 2表示是12月30日且是省外学生，12月30日距离离校时间12月31日1天，省外学生推迟1天离校，还要2天离校。输入11 15 1表示是11月15日且是省内学生，11月15日距离离校时间12月31日46天（15+16）天，还要46天离开。第一个数字X月，整型。
厦门理工学院oj哥德巴赫猜想
m0_73211704的博客
01-13 192
题目似乎有一些容易让人误解的地方，在前面的description中写的哥德巴赫猜想为欧拉的“关于偶数的哥德巴赫猜想”但是下面要求输入的数字为整数并没有要求为偶数，并且输入数字可以为。任何大于2的偶数N都是两个素数之和，假设这两个素数是X和Y，求|X-Y|最大时X和Y的值。输入一个正整数N （1< N
山东省2019_problems_山东省2019年_ACM_省赛题目_
10-02
山东省2019年ACM省赛题目，10thACM省赛题目
2020ZJCPC_2020年_2020浙江acm省赛_省赛题目_浙江ACM_
10-04
浙江2020年ACM省赛题目，第十七届省赛ACM比赛试题
2017年安徽省ACM省赛赛题解析PPT
05-03
2017年安徽省ACM省赛赛题解析PPT
ACM比赛赛资料汇总.zip
最新发布
03-08
ACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛资料汇总.zipACM比赛赛...
软件工程课件--厦门理工
01-13
厦门理工学院软件工程重点课件，考试前抱佛脚可用。
java19题厦门理工学院
12-19
java19题厦门理工学院
单片机原理及应用（厦门理工学院）
01-01
单片机原理及应用（厦门理工学院）有需要朋友快来下功夫 PPT格式的
厦门理工学院OJ题解（1270：药不能停）
qq_42988445的博客
10-21 879
Description 小明很喜欢算法和编程，他的大学学业生涯规划是：厦门理工学院程序设计大赛一等奖、福建省程序设计大赛金牌、蓝桥杯软件大赛全国一等奖、亚洲区域赛金牌、World final金牌、Google就业年薪百万。小明是懒癌晚期，他不想通过努力训练完成规划，他想通过吃药来提高智商，秒杀一众高手。 小明发现单吃一种药效果太差，他要将已有的N种药物混合成1种药再吃。已知每种药都有一定的毒性，将...
厦门理工学院oj1553
m0_73211704的博客
01-13 157
她把纸牌摆成M行N列后（ 0 < M < 100 , 0 < N < 1024 ），她想统计一下“每列”出现次数最多的字母，注意：如果一列中有多个字母出现次数一样多，那么取ASCII码最小的那个字母。聪明的你(+_+)v，帮帮她吧。2.将保存下来的数组进行统计，然后进行比较谁的数量多，也就是compare函数中的for（l）循环和下面的if所写。紧接着，每组数据第一行为两个正整数M和N，M是行数，N是列数。然后是M行，表示M个字母串。输出为T行字符串，表示对应每组数据“每列出现次数最多字母”的统计结果。
第八届福建省大学生程序设计竞赛 省赛回忆
FJUT_ACM_cjt152的博客
07-25 1540
大概是第二次参加福建省的省赛赛吧，和第一次省赛不同的是换了两个队友，然后“”实力变强了？”。 六月十一号正式赛，六月十号从学校出发开始半天的旅程，和蓝桥杯到车站的时间差不多，指导老师在车站等我们，大概一个小时后到了火车站，买票的时候买的有些晚，和他们几个隔开了，不过影响不大。两个小时后到了厦门，先感慨了了一番厦门的好，然后发现真的热，几个人背着书包在太阳下走了半个小时终于到了酒店，然后指导老师一...
fzu 2278 YYS [第八届福建省大学生程序设计竞赛 Problem G] [概率]
hint
07-22 1214
第八届福建省大学生程序设计竞赛 Problem G YYS; Yinyangshi is a famous RPG game on mobile phones. Kim enjoys collecting cards in this game. Suppose there are n kinds of cards. If you want to get a new card, you need to pay W coins to draw a card. Each time you can only d
fzu 2278 YYS 数学
老李2009
07-25 684
Problem 2278 YYS Time Limit: 1000 mSec    Memory Limit : 262144 KB  Problem Description Yinyangshi is a famous RPG game on mobile phones. Kim enjoys collecting cards in this game. Suppose
YYS FZU - 2278 (概率期望+大数)
codeswarrior的博客
04-07 580
YYS FZU - 2278 Yinyangshi is a famous RPG game on mobile phones. Kim enjoys collecting cards in this game. Suppose there are n kinds of ...
acm校赛资料c++
12-28
acm校赛资料c是指ACM（Association for Computing Machinery）校赛的相关资料之一，通常包括比赛规则、题目描述、输入输出格式、样例数据、测试数据、解题思路等内容。在ACM校赛中，每一道题目都会有对应的资料c供参赛选手参考和使用。 资料c通常是参赛选手准备比赛时不可或缺的重要资源，通过仔细阅读和理解资料c，选手可以更好地准备比赛，提高解题能力。资料c中包含的题目描述和输入输出格式能够帮助选手了解问题的具体要求，样例数据和测试数据可以用来验证自己的程序是否正确，解题思路则可以指导选手解决问题的方法和步骤。有了资料c的帮助，选手可以更快地理解问题，更好地规划解题思路，更高效地编写程序。 除了对于参赛选手的重要性，资料c也是教练和指导老师进行辅导和指导的重要工具。他们可以根据资料c中的内容为选手提供必要的帮助和指导，引导他们更好地准备比赛并提高解题能力。 综上所述，acm校赛资料c在ACM校赛中具有极其重要的作用，对于参赛选手和指导老师都是不可或缺的重要资源。通过认真研读和使用资料c，选手可以更好地准备比赛，提高解题能力，为比赛取得好成绩打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值