Day1-T1 生活大爆炸版石头剪刀布
【问题描述】
石头剪刀布是常见的猜拳游戏：石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一
样，则不分胜负。在《生活大爆炸》第二季第 8 集中出现了一种石头剪刀布的升级版游戏。
升级版游戏在传统的石头剪刀布游戏的基础上，增加了两个新手势：
现在，小 A 和小 B 尝试玩这种升级版的猜拳游戏。已知他们的出拳都是有周期性规律
的，但周期长度不一定相等。例如：如果小 A 以“石头-布-石头-剪刀-蜥蜴人-斯波克”长度
为 6 的周期出拳，那么他的出拳序列就是“石头-布-石头-剪刀-蜥蜴人-斯波克-石头-布-石头
-剪刀-蜥蜴人-斯波克-……”，而如果小 B 以“剪刀-石头-布-斯波克-蜥蜴人”长度为 5 的周
期出拳，那么他出拳的序列就是“剪刀-石头-布-斯波克-蜥蜴人-剪刀-石头-布-斯波克-蜥蜴人
-……”
已知小 A 和小 B 一共进行 N 次猜拳。每一次赢的人得 1 分，输的得 0 分；平局两人都
得 0 分。现请你统计 N 次猜拳结束之后两人的得分。
【输入】
输入文件名为 rps.in。
第一行包含三个整数：N，NA，NB，分别表示共进行 N 次猜拳、小 A 出拳的周期长度，
小 B 出拳的周期长度。数与数之间以一个空格分隔。
第二行包含 NA 个整数，表示小 A 出拳的规律，第三行包含 NB 个整数，表示小 B 出拳
的规律。其中，0 表示“剪刀”，1 表示“石头”，2 表示“布”，3 表示“蜥蜴人”， 4 表示
“斯波克”。数与数之间以一个空格分隔。
【输出】
输出文件名为 rps.out。
输出一行， 包含两个整数，以一个空格分隔，分别表示小 A、小 B 的得分
【思路】
用循环补全n次对决，模拟。
【代码】（100分）
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<iostream>
using namespace std;
int judge(int a,int b)
{
if(a==b) return 0;
if(a==0 && (b==1 || b==4)) return 0;
if(a==0 && (b==2 || b==3)) return 1;
if(b==0 && (a==1 || a==4)) return 1;
if(b==0 && (a==2 || a==3)) return 0;
if(a==1 && (b==2 || b==4)) return 0;
if(a==1 && b==3) return 1;
if(b==1 && (a==2 || a==4)) return 1;
if(b==1 && a==3) return 0;
if(a==2 && b==3) return 0;
if(a==2 && b==4) return 1;
if(b==2 && a==3) return 1;
if(b==2 && a==4) return 0;
if(a==3 && b==4) return 1;
if(b==3 && a==4) return 0;
}
int n,na,nb;
int a[205];
int b[205];
int sca,scb;
int main()
{
freopen("rps.in","r",stdin);
freopen("rps.out","w",stdout);
scanf("%d%d%d",&n,&na,&nb);
for(int i=1;i<=na;i++) scanf("%d",&a[i]);
for(int i=1;i<=nb;i++) scanf("%d",&b[i]);
for(int i=na+1;i<=n;i++) a[i]=a[i-na];
for(int i=nb+1;i<=n;i++) b[i]=b[i-nb];
for(int i=1;i<=n;i++)
{
sca+=judge(a[i],b[i]);
scb+=judge(b[i],a[i]);
}
printf("%d %d",sca,scb);
fclose(stdin);
fclose(stdout);
return 0;
}
Day1-T2 联合权值
【问题描述】
无向连通图 G 有 n 个点，n-1 条边。点从 1 到 n 依次编号，编号为 i 的点的权值为 Wi ，
每条边的长度均为 1。图上两点(u, v)的距离定义为 u 点到 v 点的最短距离。对于图 G 上的点
对(u, v)，若它们的距离为 2，则它们之间会产生�!×�!的联合权值。
请问图 G 上所有可产生联合权值的有序点对中，联合权值最大的是多少？所有联合权
值之和是多少？
【输入】
输入文件名为 link.in。
第一行包含 1 个整数 n。
接下来 n-1 行，每行包含 2 个用空格隔开的正整数 u、v，表示编号为 u 和编号为 v 的点
之间有边相连。
最后 1 行，包含 n 个正整数，每两个正整数之间用一个空格隔开，其中第 i 个整数表示
图 G 上编号为 i 的点的权值为 Wi。
【输出】
输出文件名为 link.out。
输出共 1 行，包含 2 个整数，之间用一个空格隔开，依次为图 G 上联合权值的最大值
和所有联合权值之和。由于所有联合权值之和可能很大，输出它时要对 10007 取余。
【代码】（100分）
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <vector>
#define maxn 600010
using namespace std;
struct Edge {
int v,next;
}e[maxn];
long long p[maxn],w[maxn], en = 0;
int f[maxn];
void add(int u, int v) {
en ++;
e[en].v = v;
e[en].next = f[u];
f[u] = en;
}
int main()
{
freopen("link.in","r",stdin);
freopen("link.out","w",stdout);
int n,u,v;
cin >> n;
for (int i = 1; i <= n; ++i) f[i] = -1;
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
add(u,v);
add(v,u);
}
long long total = 0, max = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= n; ++i) {
int cnt = 0;
long long sum1= 0;
int max1 = 0, max2 = 0;
for (int j = f[i]; j != -1; j = e[j].next) {
p[++cnt] = w[e[j].v];
sum1 = (sum1 + p[cnt]) % 10007;
total = (total - p[cnt] * p[cnt] + 10007) % 10007;
if (p[cnt] > max1) max2 = max1, max1 = p[cnt];
else
if (p[cnt] > max2)
max2 = p[cnt];
}
if (cnt > 0) {
total = (total + sum1 * sum1) % 10007;
}
if (total < 0) total += 10007;
if (max1 * max2 > max) max = max1 * max2;
}
cout <<max<<" "<<total<<endl;
fclose(stdin);fclose(stdout);
return 0;
}
Day1-T3 飞扬的小鸟
【问题描述】
Flappy Bird 是一款风靡一时的休闲手机游戏。玩家需要不断控制点击手机屏幕的频率来调节小鸟的飞行高度，让小鸟顺利通过画面右方的管道缝隙。如果小鸟一不小心撞到了水管或者掉在地上的话，便宣告失败。为了简化问题，我们对游戏规则进行了简化和改编：
游戏界面是一个长为 n，高为 m 的二维平面，其中有k 个管道（忽略管道的宽度）。
小鸟始终在游戏界面内移动。小鸟从游戏界面最左边任意整数高度位置出发，到达游戏界面最右边时，游戏完成。
小鸟每个单位时间沿横坐标方向右移的距离为 1，竖直移动的距离由玩家控制。如果点击屏幕，小鸟就会上升一定高度 X，每个单位时间可以点击多次，效果叠加；
如果不点击屏幕，小鸟就会下降一定高度 Y。小鸟位于横坐标方向不同位置时，上
升的高度 X 和下降的高度 Y 可能互不相同。- 小鸟高度等于 0 或者小鸟碰到管道时，游戏失败。小鸟高度为 m 时，无法再上升。现在，请你判断是否可以完成游戏。如果可以，输出最少点击屏幕数；否则，输出小鸟最多可以通过多少个管道缝隙。
【输入】
输入文件名为 bird.in。
第 1 行有 3 个整数 n，m，k，分别表示游戏界面的长度，高度和水管的数量，每两个
整数之间用一个空格隔开；
接下来的 n 行，每行 2 个用一个空格隔开的整数 X 和 Y，依次表示在横坐标位置 0~n-1
上玩家点击屏幕后，小鸟在下一位置上升的高度 X，以及在这个位置上玩家不点击屏幕时，
小鸟在下一位置下降的高度 Y。
接下来 k 行，每行 3 个整数 P，L，H，每两个整数之间用一个空格隔开。每行表示一
个管道，其中 P 表示管道的横坐标，L 表示此管道缝隙的下边沿高度为 L，H 表示管道缝隙
上边沿的高度（输入数据保证 P 各不相同，但不保证按照大小顺序给出）。
【输出】
输出文件名为 bird.out。
共两行。
第一行，包含一个整数，如果可以成功完成游戏，则输出 1，否则输出 0。
第二行，包含一个整数，如果第一行为 1，则输出成功完成游戏需要最少点击屏幕数，
否则，输出小鸟最多可以通过多少个管道缝隙。
-
| 输入样例1 | 输出样例1 |
|---|---|
| 10 10 6 | 1 |
| 3 9 | 6 |
| 9 9 | |
| 1 2 | |
| 1 3 | |
| 1 2 | |
| 1 1 | |
| 2 1 | |
| 2 1 | |
| 1 6 | |
| 2 2 | |
| 1 2 7 | |
| 5 1 5 | |
| 6 3 5 | |
| 7 5 8 | |
| 8 7 9 | |
| 9 1 3 |
-
| 输入样例2 | 输出样例2 |
|---|---|
| 10 10 4 | 0 |
| 1 2 | 3 |
| 3 1 | |
| 2 2 | |
| 1 8 | |
| 1 8 | |
| 3 2 | |
| 2 1 | |
| 2 1 | |
| 2 2 | |
| 1 2 | |
| 1 0 2 | |
| 6 7 9 | |
| 9 1 4 | |
| 3 8 10 |
-
【输入输出样例说明】
如下图所示，蓝色直线表示小鸟的飞行轨迹，红色直线表示管道
【数据范围】
对于 30%的数据：5≤n≤10，5≤m≤10，k=0，保证存在一组最优解使得同一单位时间最多
点击屏幕 3 次；
对于 50%的数据：5≤n≤20，5≤m≤10，保证存在一组最优解使得同一单位时间最多点击屏
幕 3 次；
对于 70%的数据：5≤n≤1000，5≤m≤100；
对于 100%的数据：5≤n≤10000，5≤m≤1000，0≤k n，0 X m，0 Y m，0 P n，0≤L H ≤m，
L+1 H。
【思路】
首先这道题一眼就是一个DP嘛，再看看题目描述，每一个单位时间还可以点击屏幕多次，所以说这就是一个多重背包问题。设状态f[i][j]为达到纵坐标为i横坐标为j时最小的点击屏幕次数。则有动态转移方程:
- 触摸屏幕： f[i][j]=min(f[i][j],f[i-1][j-up[i-1]]+1)
- 不触摸屏幕：f[i][j]=min(f[i][j],f[i][j+down[i-1])
- 多次触摸屏幕：f[i][j]=min(f[i][j],f[i][j-up[i-1]]+1)
这时候应该注意几个细节上的问题：
- 特殊判断飞到最高点的情况。
- 判断产生的状态是否是从上一个状态下降衍生出来的状态，如果是，则不能使用多次触摸屏幕的动态转移方程。
【代码】（100分）
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<iostream>
#define INF 0x7fffffff-1
using namespace std;
int x[10005];
int y[10005];
int up[10005];
int down[10005];
int f[2][1005];
inline int min(int a,int b)
{
if(a<b) return a;
return b;
}
inline void in(int &n)
{
n=0;
char c;
while(c>'9'||c<'0') c=getchar();
do
n=n*10+c-'0',c=getchar();
while(c>='0'&&c<='9');
}
int main()
{
freopen("bird.in","r",stdin);
freopen("bird.out","w",stdout);
int i,j,n,m,k,t,count=0,ans=INF;
in(n),in(m),in(k);
for(i=0;i<n;i++)
{
in(x[i]),in(y[i]);
down[i+1]=0,up[i+1]=m+1;
}
for(i=1;i<=k;i++) in(t),in(down[t]),in(up[t]);
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
f[i&1][j]=INF;
for(j=x[i-1]+1;j<=up[i]-1;j++)
f[i&1][j]=min(f[i&1][j],min(f[i&1^1][j-x[i-1]]+1,f[i&1][j-x[i-1]]+1));
if(up[i]-1==m)
for(j=m-x[i-1];j<=m;j++)
f[i&1][m]=min(min(f[i&1][m],f[i&1^1][j]+1),f[i&1][j]+1);
for(j=down[i]+1;j<=up[i]-1;j++)
if(j+y[i-1]<=m) f[i&1][j]=min(f[i&1][j],f[i&1^1][j+y[i-1]]);
for(j=1;j<=down[i];j++) f[i&1][j]=INF;
for(j=1;j<=m;j++)
if(f[i&1][j]!=INF) break;
if(j==m+1){printf("0\n%d\n",count);return 0;}
if(up[i]!=m+1) count++;
}
for(i=1;i<=m;i++)
ans=min(ans,f[n&1][i]);
printf("1\n%d\n",ans);
return 0;
}
Day2-T1 无线网络发射器选址
【问题描述】
随着智能手机的日益普及，人们对无线网的需求日益增大。某城市决定对城市内的公共
场所覆盖无线网。
假设该城市的布局为由严格平行的129条东西向街道和129条南北向街道所形成的网格
状，并且相邻的平行街道之间的距离都是恒定值 1。东西向街道从北到南依次编号为
0,1,2…128,南北向街道从西到东依次编号为 0,1,2…128。
东西向街道和南北向街道相交形成路口，规定编号为 x 的南北向街道和编号为 y 的东西
向街道形成的路口的坐标是（x, y）。在某些路口存在一定数量的公共场所。
由于政府财政问题，只能安装一个大型无线网络发射器。该无线网络发射器的传播范围
是一个以该点为中心，边长为 2*d 的正方形。传播范围包括正方形边界。
例如下图是一个 d = 1 的无线网络发射器的覆盖范围示意图。
现在政府有关部门准备安装一个传播参数为 d 的无线网络发射器，希望你帮助他们在城
市内找出合适的安装地点，使得覆盖的公共场所最多。
【输入】
输入文件名为 wireless.in。
第一行包含一个整数 d，表示无线网络发射器的传播距离。
第二行包含一个整数 n，表示有公共场所的路口数目。
接下来 n 行，每行给出三个整数 x, y, k, 中间用一个空格隔开，分别代表路口的坐标(x, y)
以及该路口公共场所的数量。同一坐标只会给出一次。
【输出】
输出文件名为 wireless.out。
输出一行，包含两个整数，用一个空格隔开，分别表示能覆盖最多公共场所的安装地点
方案数，以及能覆盖的最多公共场所的数量。
【思路】
简单枚举。
【代码】（100分）
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<iostream>
using namespace std;
int maxx(int a,int b) {if(a>b) return a; return b;}
int minn(int a,int b) {if(a<b) return a; return b;}
struct Node
{
int x,y;
int val;
}p[50];
int n;
int d;
int ans=0;
int num=1;
int solve(int xx,int yy)
{
int s=0;
for(int i=1;i<=n;i++)
if(p[i].x>=xx-d && p[i].x<=xx+d && p[i].y>=yy-d && p[i].y<=yy+d) s+=p[i].val;
return s;
}
int main()
{
freopen("wireless.in","r",stdin);
freopen("wireless.out","w",stdout);
scanf("%d%d",&d,&n);
for(int i=1;i<=n;i++) scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].val);
for(int i=0;i<=128;i++)
for(int j=0;j<=128;j++)
{
if(solve(i,j)>ans) ans=solve(i,j),num=1;
else if(solve(i,j)==ans) num++;
}
printf("%d %d",num,ans);
fclose(stdin);
fclose(stdout);
return 0;
}
Day2-T2 寻找道路
【问题描述】
在有向图 G 中，每条边的长度均为 1，现给定起点和终点，请你在图中找一条从起点到
终点的路径，该路径满足以下条件：
1．路径上的所有点的出边所指向的点都直接或间接与终点连通。
2．在满足条件 1 的情况下使路径最短。
注意：图 G 中可能存在重边和自环，题目保证终点没有出边。
请你输出符合条件的路径的长度。
【输入】
输入文件名为 road.in。
第一行有两个用一个空格隔开的整数 n 和 m，表示图有 n 个点和 m 条边。
接下来的 m 行每行 2 个整数 x、y，之间用一个空格隔开，表示有一条边从点 x 指向点
y。
最后一行有两个用一个空格隔开的整数 s、t，表示起点为 s，终点为 t。
【输出】
输出文件名为 road.out。
输出只有一行，包含一个整数，表示满足题目᧿述的最短路径的长度。如果这样的路
径不存在，输出-1。
【思路】
以终点为起点bfs一遍，找出不符合要求的点，去掉。再正着bfs一遍，得出最后答案。
【代码】（100分）
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<iostream>
using namespace std;
struct Edge
{
int from,to;
int next;
}eage[500005];
int n,m;
int head[10005];
int tot=0;
int s,t;
int dis[10005];
int que[100005];
int f=0,r=1;
bool flag[10005];
void add(int x,int y)
{
eage[++tot].from=x;
eage[tot].to=y;
eage[tot].next=head[x];
head[x]=tot;
}
int main()
{
freopen("road.in","r",stdin);
freopen("road.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
add(x,y);
}
for(int i=1;i<=m;i++)
add(eage[i].to,eage[i].from);
scanf("%d%d",&s,&t);
memset(dis,-1,sizeof dis);
memset(que,0,sizeof que);
que[r++]=t;
dis[t]=0;
while(r-f>1)
{
int pos=que[++f];
for(int i=head[pos];i;i=eage[i].next)
if(i>m && !flag[eage[i].to])
{
if(dis[eage[i].to]==-1)
{
dis[eage[i].to]=dis[pos]+1;
que[r++]=eage[i].to;
}
}
}
for(int i=1;i<=m;i++)
if(dis[eage[i].to]==-1) flag[eage[i].from]=1;
memset(dis,-1,sizeof dis);
memset(que,0,sizeof que);
f=0,r=1;
que[r++]=s;
dis[s]=0;
while(r-f>1)
{
int pos=que[++f];
for(int i=head[pos];i;i=eage[i].next)
if(i<=m && !flag[eage[i].to])
{
if(dis[eage[i].to]==-1)
{
dis[eage[i].to]=dis[pos]+1;
que[r++]=eage[i].to;
}
}
}
cout<<dis[t];
fclose(stdin);
fclose(stdout);
return 0;
}
Day2-T3 解方程
【问题描述】
已知多项式方程：
a[0]+a[1]*x+a[2]*x^2+a[3]*x^3+……+a[n]*x^n= 0
求这个方程在[1, m]内的整数解（n 和 m 均为正整数）。
【输入】
输入文件名为 equation.in。
输入共 n+2 行。
第一行包含 2 个整数 n、m，每两个整数之间用一个空格隔开。
接下来的 n+1 行每行包含一个整数，依次为a[0],a[1],a[2]….a[n]。
【输出】
输出文件名为 equation.out。
第一行输出方程在[1, m]内的整数解的个数。
接下来每行一个整数，按照从小到大的顺序依次输出方程在[1, m]内的一个整数解。
【思路】
解方程，一看数据好大，因为高次方程没有解的方法，所以1~m只能枚举，但是ai是高精度数，但是我们可以mod一个数，因为写高精度没有必要。如果f(x) mod p = 0 x非常有可能是解，这样就不用写高精度了，然后f(x) mod p ！= 0 那么f(x + Np) = f(x) != 0 那么实际上我们没有必要枚举1~M 因为我们以枚举0~P-1,然后推测出p~M这些数哪些一定不是答案。多找几个p把不是答案的剔除，剩下的基本上就是解了。
【代码】（100分）
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<iostream>
using namespace std;
int prime[5]={11261,19997,22877,21893,14843};
int n,m;
char ch[10005];
int a[5][105];
int val[5][23000];
int ans[1000005];
int Qin(int k,int x)
{
int v[105];
v[0]=a[k][n];
for(int i=1;i<=n;i++)
{
v[i]=v[i-1]*(x%prime[k])+a[k][n-i];
v[i]%=prime[k];
}
return v[n];
}
bool judge(int x)
{
for(int k=0;k<5;k++)
if(val[k][x%prime[k]]!=0) return 0;
return 1;
}
int main()
{
freopen("equation.in","r",stdin);
freopen("equation.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=0;i<=n;i++)
{
int flag=1,start=1;
scanf("%s",ch+1);
int len=strlen(ch+1);
if(ch[1]=='-') flag=-1,start=2;
for(int k=0;k<5;k++)
for(int j=start;j<=len;j++)
{
a[k][i]=a[k][i]*10+(ch[j]-'0');
a[k][i]%=prime[k];
}
for(int k=0;k<5;k++)
a[k][i]*=flag;
}
for(int k=0;k<5;k++)
for(int i=1;i<=prime[k];i++)
val[k][i]=Qin(k,i);
for(int i=1;i<=m;i++)
if(judge(i)) ans[++ans[0]]=i;
printf("%d\n",ans[0]);
for(int i=1;i<=ans[0];i++)
printf("%d\n",ans[i]);
fclose(stdin);
fclose(stdout);
return 0;
}
扫一扫
2132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
