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

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
");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
",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
",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
",e[i].id_person,e[i].message);
        }
        printf("
");
    }
    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
");
        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
",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
",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
",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
",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
");
        else printf("No
");
    }
    return 0;
}