江西财经大学第一届程序设计竞赛

A:贪玩蓝月

题目描述

"挤需体验五番钟，里造会挨上这款游戏!"
怎么可能嘛！当我是傻子吗！#?%!“”@……
于是我就去玩了，然后我果然成功证明，我是正确的，这破游戏，真的很无聊.

有多无聊呢，和这道题一样.

------------------------------------

问题有两种情况
0 给出两个100以内的正整数做加法
1 给出一个字符串问有多少个字符（字符串长度不超过100000）

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每组样例先输入一个整数N（0或者1）若N为0，则输入两个整数a,b（0<=a,b<=100）若N为1，则输入一个字符串s

输出描述:

输出T行每行输出一个样例对应的结果

示例1

输入

2
0 1 1
1 aa

输出

2
2
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) (memset(a,0,sizeof(a)))
#define ll long long
int k,n,a,b;
char s[100006];
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&k);
        if(k==0)
        {
            scanf("%d%d",&a,&b);
            cout<<a+b<<endl;
        }
        else
        {
            cin>>s;
            cout<<strlen(s)<<endl;
        }
    }
    return 0;
}

B：大吉大利

题目描述

给出一个出生日期，比如：1999-09-09，
问：从出生那一天开始起，到今天2018-04-21为止（包括出生日期和今天），有多少天，年月日都不包含数字4？

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每个样例一行，包含一个字符串“yyyy-mm-dd”（1990<=yyyy<=2018）题目保证测试数据的正确性

输出描述:

输出题意要求的天数

示例1

输入

1
1999-09-09

输出

5020分情况暴力跑
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) (memset(a,0,sizeof(a)))
#define ll long long
int a,b,c;
int kk[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int solve(int n)
{
    if(n%400==0 || (n%4==0 && n%100!=0)) return 1;
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d-%d-%d",&a,&b,&c);
        int pos=0,n;
        if(a>=2018 && b>=4) {printf("0\n");return 0;}
        else if(a==2018 && b<4)
        {
            for(int i=b+1;i<4;i++)
            {
                int  p;
                if(i==2 && solve(2018)) p=kk[i]+1;
                else p=kk[i];
                for(int k=1;k<=p;k++)
                {
                    pos+=(k%10==4?0:1);
                }
            }
            if(b==2 && solve(2018)) n=kk[b]+1;
            else n=kk[b];
            for(int i=c;i<=n;i++)
                pos+=i%10==4?0:1;
        }
        else if(a<2018)
        {
            if(a%10==4) pos+=0;
            else if(a%10!=4)
            {
                if(b==2 && solve(a)) n=kk[b]+1;
                else n=kk[b];
                for(int i=c;i<=n;i++)
                    pos+=(i%10==4?0:1);
                for(int i=b+1;i<=12;i++)
                {
                    if(i%10==4) continue;
                    int  p;
                    if(i==2 && solve(a)) p=kk[i]+1;
                    else p=kk[i];
                    for(int k=1;k<=p;k++)
                    {
                        pos+=(k%10==4?0:1);
                    }
                }
            }
            for(int i=a+1;i<2018;i++)
            {
                if(i%10==4) continue;
                for(int j=1;j<=12;j++)
                {
                    if(j%10==4) continue;
                    int  p;
                    if(j==2 && solve(i)) p=kk[j]+1;
                    else p=kk[j];
                    for(int k=1;k<=p;k++)
                    {
                        pos+=(k%10==4?0:1);
                    }
                }
            }
            for(int i=1;i<=3;i++)
            {
                if(i%10==4) continue;
                int  p;
                if(i==2 && solve(2018)) p=kk[i]+1;
                else p=kk[i];
                for(int k=1;k<=p;k++)
                {
                    pos+=(k%10==4?0:1);
                }
            }
        }
        printf("%d\n",pos);
    }
    return 0;
}

C：今晚吃鸡

题目描述

决赛圈还剩下两个人，“伏地魔”XDD和跑毒进圈的FZL，XDD拿着狙击枪AWM瞄准并准备射击奔跑中的FZL。

XDD知道自己只有这一次机会，如果失误了，他就会被大哥FZL空中360度甩狙一枪带走。

那么XDD能吃鸡吗，请你帮助他。

-------------------------------------------

为了便于分析，子弹，XDD，FZL都假设为原点，子弹水平射出，FZL在奔跑过程中与XDD的距离不变。

子弹下坠的加速度为9.8米每秒。

给出 XDD和FZL的距离 浮点数 L 、子弹的速度 浮点数V1、FZL奔跑的速度浮点数 V2

XDD需要知道从射击到击中目标这段时间内 子弹下坠的距离 L1和 FZL跑动的距离L2，从而预判射击的位置，请你帮他计算。

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每个样例一行，包括三个浮点数 L V1 V2（0<L,V1,V2<=10000）

输出描述:

输出T行每个测试用例输出一行对应的结果L1 L2（一个空格隔开，结果保留6位小数）

示例1

输入

1
100 1000 10

输出

0.049000 1.000000水题
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) (memset(a,0,sizeof(a)))
#define ll long long
int T;
int main(){
    cin>>T;
    while(T--)
    {
        double L,v1,v2;
        scanf("%lf%lf%lf",&L,&v1,&v2);
        double t = L/v1;
        double x = 0.5*9.8*t*t;
        double XX = v2*t;
        printf("%.6f %.6f\n",x,XX);
    }
    return 0;
}

D:SSR

题目描述

事情，是这样的。
有这么一天双休日的中午。
我刚把我衣服扔进了洗衣机，然后拿了个小板凳坐在旁边发呆。
然后突然想到这么无聊干脆玩会阴阳师好了，于是从斗篷帽子里掏出我的手机登录了阴阳师。
看着更新公告里写着的新SSR式神一目连感叹了一下：我要是能有个一目连该多好啊
看了一眼我家帅气的扛把子咕咕，正准备肝困难的时候发现庭院里那一串灯笼里的调查问卷有蝴蝶在绕，于是点进去填了一波在最结尾写上了我当时的愿望：我想要一目连。
然后奖励了一个符，顺手就抽了。本来以为又是R卡，没想到手机震动了一下。
握草！！！一目连！！！！
当时我就激动的站了起来使劲看了一眼然后仰天大笑以及截图装逼。

---------------------------------------------------------------------------------------

SSR全称为superior super rare，特级超稀有。一般为卡牌类游戏最高稀有等级。

题目是给出三个字符，求其升级到SSR所需要的次数。

最小为AAA，最大为SSR；

SSQ升级到SSR需要升级1次，

SRR升级到SSR需要升级19次。

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每个样例一行，包含三个连续的大写字母（A - S）

输出描述:

每个样例输出一行升级到SSR所需的次数

示例1

输入

3
SSR
SRR
AAA

输出

0
19
6857

备注:

SRR升级到SSR的过程：SRR -> SRS -> SSA ->SSB -> SSC -> ……->SSR 共19次注意最顶是19个字符
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) (memset(a,0,sizeof(a)))
#define ll long long
string a,b;
int t;
int main()
{
    int n;
    cin>>n;
    while(n--){
        char a,b,c;
        cin>>a>>b>>c;
        int x=‘S‘-a;
        int y=‘S‘-b;
        int z=‘R‘-c;
        if(z<0)
        {
            y--;
            z+=19;
        }
        if(y<0)
        {
            x--;
            y+=19;
        }
        int sum = x*19*19+y*19+z;
        cout<<sum<<endl;
    }
    return 0;
}

E:消息序列

题目描述

当你的好友给你发来一条消息，你的消息列表上就会置顶显示该好友的名字以及该好友发给你的消息总数，换句话说，你的消息列表里的好友是按跟你发消息的时间进行排序的，给你发消息的时间离当前时间越近的好友将排到越前面。当然，你可能会手动置顶一些好友，那么其他的好友给你发消息时，他们的名字就只能在你手动置顶好友的后面再置顶了。如果消息被你查看或者忽略，又或者你把好友消息删除了，消息总数将重置为0。

根据用户的需求，有以下几个功能，需要你来实现：
（1）recv：收到一条好友消息，对于手动置顶好友的消息，将在“手动置顶好友列表”里置顶；对于其他好友的消息，将在“手动置顶好友列表”之下的消息列表里置顶，同时都需要显示该好友的消息总数。
（2）view：查看好友消息，将使该好友消息数变为0。
（3）up：手动置顶好友。
（4）down：取消手动置顶。
（5）delete：删除好友消息，这个操作将使该好友从消息列表中删除，同时取消对该好友的手动置顶（如果存在的话）。

假设初始消息列表为空，经过了一系列好友消息的操作之后，最终的消息列表将是怎么样的呢？

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例。每组样例第一行输入一个整数M，表示操作数（1≤M≤1000000）；接下来M行，每行输入一个操作，由一个操作类型和一个好友id构成，之间以空格分开，操作类型如上面5个英文单词表示，例如：“recv 123456”表示接收到id为123456的好友的一条消息，“delete 123456”表示在消息列表中删除 id 为123456的好友的消息记录。为了简化问题，一开始消息列表为空并假设好友名字id由六位数字“唯一”标识（000000≤id≤999999），题目保证输入数据的一致性。

输出描述:

每组样例，输出最后的消息列表，自顶向下，每行输出一个：“好友id 消息数”。每组样例后空一行。

示例1

输入

1
13
recv 000001
recv 000002
up 000002
view 000001
recv 000002
recv 000004
up 000004
up 000001
recv 000004
recv 000003
view 000001
view 000004
down 000002

输出

000004 0
000001 0
000003 1
000002 2模拟
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
struct node
{
    int message;
    int is_up;
    int priority;
    int id_person;
    bool operator<(const node a)
    {
        return a.is_up!=is_up?a.is_up<is_up:a.priority<priority;
    }
}e[1000006];
int t,n,x;
char s[15];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(e,0,sizeof(e));
        scanf("%d",&n);
        int time=1;
        for(int i=0;i<n;i++)
        {
            scanf("%s %d",&s,&x);
            e[x].id_person=x;
            if(s[0]==‘r‘) {e[x].message++;e[x].priority=time++;}
            else if(s[0]==‘v‘) e[x].message=0;
            else if(s[0]==‘u‘) e[x].is_up=1;
            else if(s[1]==‘o‘) e[x].is_up=0;
            else {e[x].priority=0;e[x].is_up=0;e[x].message=0;}
        }
        sort(e,e+1000000);
        for(int i=0;i<1000000;i++)
        {
            if(e[i].priority)
                printf("%06d %d\n",e[i].id_person,e[i].message);
        }
        printf("\n");
    }
    return 0;
}

F:解方程

题目描述

对于方程 2018 * x ^ 4 + 21 * x + 5 * x ^ 3 + 5 * x ^ 2 + 14 = Y，
告诉你Y的值，你能找出方程在0~100之间的解吗？

输入描述:

第一行输入一个正整数T（表示样例个数）接下来T组样例每组样例一行，输入一个实数Y

输出描述:

一行输出一个样例对应的结果，输出方程在0~100之间的解，保留小数点后4位小数；如果不存在，输出 -1

示例1

输入

2
1
20180421

输出

-1
9.9993边界处理之后二分搜索
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
int n;
double ans,y;
int solve(double x)
{
    return 2018*x*x*x*x+21*x+5*x*x*x+5*x*x+14>=y?1:0;
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        ans=2018*100.0*100.0*100.0*100.0+21*100.0+5*100.0*100.0*100.0+5*100.0*100.0+14;
        scanf("%lf",&y);
        if(y<14 || y>ans) printf("-1\n");
        else
        {
            double l=0.00,r=100.00;
            while((r-l)>1e-7)
            {
                double mid=(r+l)/2;
                if(solve(mid)) r=mid;
                else l=mid;
            }
            printf("%.4lf\n",l);
        }
    }
    return 0;
}

G:小Q的口袋校园

题目描述

周末，小Q喜欢在PU口袋校园上参加各种活动刷绩点，体验丰富多彩的大学生活。

但是每个活动有各自的开始时间、结束时间、Happy值以及绩点数，活动之间可能存在时间冲突。

小Q是一个认真踏实的女孩，她在同一时间只会参加一个活动。

给出每一天的活动数，求小Q在同一天内所能获得的最大Happy值 与 绩点数。

小Q是一个活泼开朗的女孩，她总是寻求最大的Happy值，如果Happy值相同，才会尽可能使绩点数更多。

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每组样例第一行输入一个整数N（表示有几项活动）接下来N行，每行输入s,e,h,p 4个整数，分别代表一个活动的开始时间、结束时间、Happy值以及绩点数0<=s<e<=24,1<=h,p<=100，1<=T,N<=20

输出描述:

输出T行一行输出一个样例对应的结果小Q在一天内所能获得的最大 Happy值 与 绩点数

示例1

输入

1
4
1 3 1 1
2 5 2 1
3 7 2 1
5 8 1 2

输出

3 3

说明

有两种方案1）选择 第1、3两个活动，可以获得 Happy值 3 和 绩点数 2；2）选择 第2、4两个活动，可以获得 Happy值 3 和 绩点数 3.dfs就可以，数据量小
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
int t,n,a,b,c,d,ans,pos;
int vis[25];
vector<int>v[25];
struct node
{
    int end;
    int h,w;
}e[30];
void dfs(int now,int k,int p)
{
    int ok=0,pp;
    for(int j=now;j<=24;j++)
    {
        if(vis[j])
        {
            ok=1;
            break;
        }
    }
    if(!ok)
    {
        if(ans<k){ans=k;pos=p;}
        else if(ans==k && pos<p){pos=p;}
        return ;
    }
    for(int j=now;j<=24;j++)
    {
        if(vis[j])
        {
            ok=1;
            pp=j;
            for(int i=0;i<v[pp].size();i++)
            {
                dfs(e[v[pp][i]].end,k+e[v[pp][i]].h,p+e[v[pp][i]].w);
            }
        }
        else continue;
    }
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<=24;i++)
            v[i].clear();
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&a,&b,&c,&d);
            v[a].push_back(i);
            e[i].end=b;
            e[i].h=c;
            e[i].w=d;
            vis[a]=1;
        }
        ans=0,pos=0;
        for(int i=0;i<=24;i++)
        {
            if(vis[i])
            {
                dfs(i,0,0);
            }
        }
        printf("%d %d\n",ans,pos);
    }
    return 0;
}

贪心

/*#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
typedef long long ll;*/
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
struct node
{
    int u,v,h,w;
    bool operator<(const node a)
    {
        return a.u>u;
    }
}e[36];
int main()
{
    int t,n,ans[26],pos[26];
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d%d%d%d",&e[i].u,&e[i].v,&e[i].h,&e[i].w);
        sort(e,e+n);
        memset(ans,0,sizeof ans);
        memset(pos,0,sizeof pos);
        for(int i=0;i<n;i++)
        {
            for(int j=e[i].v;j<=24;j++)
            {
                if(ans[j]<ans[e[i].u]+e[i].h)
                {
                    ans[j]=ans[e[i].u]+e[i].h;
                    pos[j]=pos[e[i].u]+e[i].w;
                }
                else if(ans[j]==ans[e[i].u]+e[i].h)
                    pos[j]=max(pos[j],pos[e[i].u]+e[i].w);
            }
        }
        printf("%d %d\n",ans[24],pos[24]);
    }
    return 0;
}

H:小P的数学问题

题目描述

晚上，小P喜欢在寝室里一个个静静的学习或者思考，享受自由自在的单身生活。

他总是能从所学的知识散发出奇妙的思维。

今天他想到了一个简单的阶乘问题，

0！= 1

1！= 1

2！= 1 * 2 = 2

3！= 1 * 2 * 3 = 6

4！= 1 * 2 * 3 *4 = 24

5！= 1 * 2 * 3 *4 * 5 = 120

。

。

如果 n=1000000000，那么n的阶乘会是多少呢，小P当然知道啦，那么你知道吗？

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每组样例一行，输入一个整数N（0<=N<=1000000000）

输出描述:

输出T行每一行输出N的阶乘 N！（由于这个数比较大，所以只要输出其对1000000007取膜的结果即可）

示例1

输入

2
0
1000000000

输出

1
698611116分块打表
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
ll ans[120]={1,682498929,491101308,76479948,723816384,67347853,27368307,625544428,199888908,
    888050723,927880474,281863274,661224977,623534362,970055531,261384175,195888993,66404266,
    547665832,109838563,933245637,724691727,368925948,268838846,136026497,112390913,135498044,
    217544623,419363534,500780548,668123525,128487469,30977140,522049725,309058615,386027524,
    189239124,148528617,940567523,917084264,429277690,996164327,358655417,568392357,780072518,
    462639908,275105629,909210595,99199382,703397904,733333339,97830135,608823837,256141983,
    141827977,696628828,637939935,811575797,848924691,131772368,724464507,272814771,326159309,
    456152084,903466878,92255682,769795511,373745190,606241871,825871994,957939114,435887178,
    852304035,663307737,375297772,217598709,624148346,671734977,624500515,748510389,203191898,
    423951674,629786193,672850561,814362881,823845496,116667533,256473217,627655552,245795606,
    586445753,172114298,193781724,778983779,83868974,315103615,
    965785236,492741665,377329025,847549272,698611116};
int main()
{
    ll t,n;
    cin>>t;
    while(t--)
    {
        cin>>n;
        ll k=n/10000000;
        ll pos=ans[k];
        for(ll i=k*10000000+1;i<=n;i++)
        {
            pos=pos*i%MOD;
        }
        printf("%lld\n",pos);
    }
    return 0;
}

I:小P和小Q

题目描述

小P和小Q是好朋友，今天他们一起玩一个有趣的游戏。

他们的初始积分都为1，赢的人可以将自己的分数乘以 (K的平方)，而输的人也能乘以K。

他们玩的太开心了，以至于忘了自己玩了多久，甚至 K 是多少和游戏进行的回合数 N 都忘了。

现在给出他们俩最终的积分a,b，请问是否存在正整数K、N满足这样的积分，判断他们的游戏结果是否可信。

输入描述:

第一行输入一个整数T（表示样例个数）接下来T组样例每组样例一行，输入两个正整数a,b（0<a,b<=1e9）

输出描述:

输出T行一行输出一个样例对应的结果若结果可信，输出 Yes否则，输出 No

示例1

输入

6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000

输出

Yes
Yes
Yes
No
No
Yes

备注:

每回合的K可能不同a=k1^1k2^2k3^1;b=k1^2k2^1k3^2;a*b=k1^3k2^3k3^3;
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#pragma comment(linker, "/stck:1024000000,1024000000")
#define lowbit(x) (x&(-x))
#define max(x,y) (x>=y?x:y)
#define min(x,y) (x<=y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.1415926535897932384626433832
#define ios() ios::sync_with_stdio(true)
#define INF 0x3f3f3f3f
#define mem(a) ((a,0,sizeof(a)))
#define ll long long
ll a,b,n;
int main()
{
    scanf("%lld",&n);
    while(n--)
    {
        scanf("%lld%lld",&a,&b);
        double k=pow(a*b,1.0/3);
        ll c=k+0.5;
        if(c*c*c==a*b) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

原文地址：https://www.cnblogs.com/shinianhuanniyijuhaojiubujian/p/8906010.html

时间： 2024-10-11 22:25:10

江西财经大学第一届程序设计竞赛的相关文章

HDU 6467 简单数学题 【递推公式 &amp;&amp; O(1)优化乘法】（广东工业大学第十四届程序设计竞赛）

传送门:http://acm.hdu.edu.cn/showproblem.php?pid=6467 简单数学题 Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 308    Accepted Submission(s): 150 Problem Description 已知 F(n)=∑i=1n(i×∑j=inCij) 求 F(n) m

FZU-2231 平行四边形数 From 福州大学第十三届程序设计竞赛

FZU-Problem 2231 平行四边形数 Accept: 66 Submit: 210 Time Limit: 2000 mSec Memory Limit : 32768 KB Problem Description 在一个平面内给定n个点,任意三个点不在同一条直线上,用这些点可以构成多少个平行四边形?一个点可以同时属于多个平行四边形. Input 多组数据(<=10),处理到EOF. 每组数据第一行一个整数n(4<=n<=500).接下来n行每行两个整数xi,yi(0<=

1150: 零起点学算法57——程序设计竞赛

1150: 零起点学算法57--程序设计竞赛 Time Limit: 1 Sec  Memory Limit: 64 MB   64bit IO Format: %lldSubmitted: 1303  Accepted: 742[Submit][Status][Web Board] Description 每年5月份,省里都要举行程序设计竞赛. 为了让最优秀的学生去参加比赛,我们一般需要做一个选拔工作. 现在你来帮老师完成这个任务哦. Input 多组测试数据,每组数据一行,该行先输入一个整数

福州大学第十届程序设计竞赛 -- 部分题解

题目传送:福州大学第十届程序设计竞赛 Problem A 神庙逃亡 水题 AC代码: #include<cstdio> #include<cmath> #include<iostream> using namespace std; int s, h, vx, vy; int main() { int w; cin >> w; while(w--){ cin >> s >> h >> vx >> vy; long

湖南省第七届程序设计竞赛 最优对称路径

http://acm.nyist.net/JudgeOnline/problem.php?pid=564 湖南省第七届大学生计算机程序设计竞赛 题目G 最优对称路径 给一个n行n列的网格,每个格子里有一个1到9的数字.你需要从左上角走到右下角,其中每一步只能往上.下.左.右四个方向之一走到相邻格子,不能斜着走,也不能走出网格,但可以重复经过一个格子.为了美观,你经过的路径还必须关于"左下-右上"这条对角线对称.下图是一个6x6网格上的对称路径. 你的任务是统计所有合法路径中,数字之和最

广东工业大学第十四届程序设计竞赛 鸽子数

Problem Description 通常来说,题面短的题目一般都比较难,所以我要把题面写得很长很长.通常来说,题面短的题目一般都比较难,所以我要把题面写得很长很长.通常来说,题面短的题目一般都比较难,所以我要把题面写得很长很长.鸽子数字由以下过程定义:从任何正整数开始,将数字替换为其各个数位的平方和,并重复该过程,直到该数字等于1.如果不能,则这个数字不是鸽子数.例如7是鸽子数,因为7->49->97->130->10->1.(7*7=49,4*4+9*9=97,9*9+

[2017年第0届浙江工业大学之江学院程序设计竞赛决赛 I] qwb VS 去污棒（并查集，按秩合并，最小生成树，LCA）

题目链接:http://115.231.222.240:8081/JudgeOnline/problem.php?cid=1005&pid=8 题意:中文题面. 手动画一下会发现所求边必然存在于最大生成树上,那么就可以首先构造一棵最大生成树. 问题转化成一棵树上求两个点之间的链上的最短边,用倍增lca就可以做了,但是我不会. 于是可以考虑建树时的操作,在求最大生成树的时候按秩合并,即集合大的根要做集合小的根的父亲,这样连一条有向边,保证路径上的所有边没有变化,并且能够维持整棵树高不会超过log(

（未完成）[HDUOJ]“字节跳动-文远知行杯”广东工业大学第十四届程序设计竞赛

solved 5 A(签到) 题意:两个人随机得到0或1其中之一数字,每个人都可以猜对方的数字是什么,有一个人猜对就算成功,问最优策略下00,01,10,11四种情况两人的成功概率分别是多少. 题意不明的签到题,题面说两人不能沟通,以为就是两个人随便猜,成功率都是1-0.5*0.5=0.75.结果是两个人可以提前商量好策略,那显然可以其中一个人猜和自己相同的数,另一个人猜和自己不同的数,那么所有的成功率都是100%. #include<bits/stdc++.h> using namespac

东南大学第十三届程序设计竞赛初赛题解

问题 A: 天梯评分系统 题目描述 在一个下雨的日子,沈学姐和四个好基友约定无事一同打dota(dota是一个5对5的MOBA类游戏)因为想证明谁最NB,他们就全部注册新号去爬天梯了.天梯有一套完整的评分系统,它可以根据每位选手每局的数据进行评分,因为dota的英雄既有辅助又有ganker还有后期,所以不同的英雄的评分标准不一样.可惜那天天梯服务器维护,无法进行评分.于是,他们记录下每一局的数据,找你来帮忙,希望你能够帮他们仿照天梯编一个评分系统,以便于他们比较谁是真正的神牛. 已知对于每个账号