一、Fake news(D)
题目链接:Fake news
输入
5
1
2
3
4
5
输出
Fake news!
Nobody knows it better than me!
Nobody knows it better than me!
Nobody knows it better than me!
Nobody knows it better than me!
题目大意: 给你一个n， x等于1~n的平方和,问x是否可以被开方，如果可以的话输出Fake news，否则输出另一个结果。
x
=
∑
i
=
1
n
i
2
x=\sum_{i=1}^{n}i^{2}
x=i=1∑ni2
解题思路:
首先我们发现x可以用通项公式求出来，但是我们发现n是1015数量级，所以x的值我们是求不出来的。那么我们直接可以来猜答案，在可以求解的范围内，发现只有n=1和n=24符合条件。
x
=
∑
i
=
1
n
i
2
=
n
(
n
+
1
)
(
2
n
+
1
)
6
x=\sum_{i=1}^{n}i^{2}=\frac{n(n+1)(2n+1)}{6}
x=i=1∑ni2=6n(n+1)(2n+1)
这个题比较简单，第一感觉就是猜，但是图快，没有进行测试，直接判定n=1的情况，导致漏掉了n=24的情况，wa了一次，所以不能盲猜，还是要跑程序判定一下。
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<string>
#include<sstream>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<vector>
#define ll long long
using namespace std;
const ll mod = 1e9+7;
int main()
{
ll t,n;
scanf("%lld",&t);
while(t--)
{
scanf("%lld",&n);
if(n==1||n==24)
printf("Fake news!\n");
else
printf("Nobody knows it better than me!\n");
}
return 0;
}
二、Mask Allocation (B)
题目链接：Mask Allocation
输入:
2
5 4
3 3
输出:
8
4 4 4 4 1 1 1 1
3
3 3 3
题目大意： 你现在有n*m个口罩，现在有n个重症医院，m个轻症医院。口罩需要放在盒子里才能分配，现在问你怎样分配使得口罩既能全部平均分给n个医院，也能全部平均分配给m个医院。求出最少的盒子数，并且按照字典序大的结果输出每个盒子的口罩数量。
解题思路： 我们先假设n<m,那么首先每一个盒子能装的数量最多为n个（如果大于n个，则无法分配给m个医院，每个n个），我们现在假设分配到m个盒子，每个盒子n个口罩，那么可以成功分配给m个医院。现在我们对已有的盒子进行组合，我们现在把盒子叠放在一起，叠成n组，那么叠完后就变成了n叠，每一叠m/n个盒子，然后剩余m%n个盒子，那么现在我们的问题就变成了将这（m%n）*n个口罩进行分配，既能平均分配给m%n个医院，也能平均分配给n个医院，那么这就是一个递推的过程了，终止条件就是m%n=0,也就是刚好平均分配完。（如果有读者不清楚，可画图，逻辑更加清楚）
代码： 因为既要打印结果，也要打印分配情况，那么干脆跑两遍dfs。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<queue>
#include<map>
#define debug(a) cout << "*" << a << "*" << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int flag=1;
int dfs(int n,int m)
{
if(n==0)
return 0;
else
return m-(m%n)+dfs(m%n,n);
}
void print(int n,int m)
{
if(n==0)
return;
else
{
for(int i=0;i<m-(m%n);i++)
{
if(flag==1)
{
flag=0;
printf("%d",n);
}
else
printf(" %d",n);
}
print(m%n,n);
}
}
int main()
{
int t,n,m;
scanf("%d",&t);
while(t--)
{
flag=1; //控制输出格式
scanf("%d%d",&n,&m);
if(n>m)
swap(n,m);
printf("%d\n",dfs(n,m));
print(n,m);
printf("\n");
}
}
三、Dividing (H)
题目链接：Dividing
输入：
3 3
输出：
8
输入：
3 9
输出：
14
题目大意： 给定n和k的取值范围，问你有多少个合法的二元组，合法的二元组就是那三条规则来确定。
解题思路： 我们从给定的三条规则中可以发现，对于任何一个k，只要n%k=0或者n%k=1,那么这一组(n,k)就是合法的。问题就转换为求这样的一个
结果：
∑
n
=
1
N
∑
k
=
1
K
(
n
%
k
=
=
0
∣
∣
n
%
k
=
=
1
)
\sum_{n=1}^{N}\sum_{k=1}^{K}(n\%k==0||n\%k==1)
n=1∑Nk=1∑K(n%k==0∣∣n%k==1)
把这个式子拆成两部分：
∑
k
=
1
K
N
k
和
∑
k
=
2
K
(
N
−
1
k
+
1
)
\sum_{k=1}^{K}\frac{N}{k}和\sum_{k=2}^{K}(\frac{N-1}{k}+1)
k=1∑KkN和k=2∑K(kN−1+1)
前面这部分计算出n%k==0的情况，后面这部分会漏掉n=1的情况因此对于每一个k都需要加1（例如：假设N=100，k=3，那么(N-1)/k=33,实际有34组合法，因此+1）
代码： 因为这题的K非常大，因此我们是不能线性遍历k,其实可以发现对于不同的k来说N/k的值是可以相同的（例如：N=100，51<=k<=100，在这个范围内，N/k的值都是1）那么我们可以先求出N/k,然后算出k的最大取值，从而实现跳着遍历而不是k++。
#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<queue>
#include<map>
#define debug(a) cout << "*" << a << "*" << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll mod = 1e9+7;
int main()
{
ll n,k;
ll ans=0;
scanf("%lld%lld",&n,&k);
///n%k==0
for(ll i=1,j;i<=k;i=j+1)// j为同l的最右顶点
{
ll l=n/i; //l为周期长度
if(l==0)
break;
j=min(k,n/l);
ans=(ans+l*((j-i+1)%mod))%mod;
}
//n%k==1
for(ll i=2,j;i<=k;i=j+1)
{
ll l=(n-1)/i;
if(l==0)
break;
j=min(k,(n-1)/l);
ans=(ans+l*((j-i+1)%mod))%mod;
}
ans=(ans+k-1)%mod;
cout<<ans<<endl;
}
四、Pointer Analysis (J)
题目链接：Pointer Analysis
输入：
5
B.f = A
C = B.f
C = x
A = o
B = o
输出：
A: o
B: o
C: ox
D:
E:
F:
G:
H:
I:
J:
K:
L:
M:
N:
O:
P:
Q:
R:
S:
T:
U:
V:
W:
X:
Y:
Z:
题目大意： 现在存在26个对象(a,b,c,…,z)，每个对象存在26个成员变量(a.a,a.b,a.c,…,a.z,…,z.z)。还有26个普通变量(A,B,…,Z)。给定你n条赋值语句，你现在可以通过任意顺序，次数来执行这些赋值语句，最后问你每一个普通变量所能指向的最大对象集合。
解题思路： 首先要看明白这两条赋值语句的意思。
1. A=B. f：A可以指向B所指向的每一个对象的成员变量f所指向的对象。
2. A.f=B：A所指向的每一个对象的成员变量f可以指向B所指向的对象。
搞清楚了这两条赋值语句之后我们，会发现成员变量是会指向对象的，而且普通变量可以通过成员变量进行赋值。那么我们可以用一个二维数组来表示普通变量所指向的对象，用一个三维数组来表示成员变量所指向的对象。（例如：ans[A][a]=1表示A指向对象a；tmp[a][f][b]表示a的成员变量f指向对象b）
现在我们只需要循环执行n次，就可以让普通变量指向最多的对象。更多细节可以查看代码。
代码：
#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<queue>
#include<map>
#define debug(a) cout << "*" << a << "*" << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int ans[30][30]; //ans[A][a]=1表示A指向对象a；
int tmp[30][30][30]; //tmp[a][f][b]表示a的成员变量f指向对象b
string S1[205],S2[205];
int main()
{
int n;
char temp;
cin>>n;
for(int i=0;i<n;i++)
cin>>S1[i]>>temp>>S2[i];
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
int x=S1[j][0]-'A'; //x为变量
int y=S2[j][0]-'A';
if(S1[j].size()==1&&S2[j].size()==1)
{
if(S2[j][0]>='a') //A=a
ans[x][S2[j][0]-'a']=1;
else //A=B
{
for(int k=0;k<26;k++)
{
ans[x][k]|=ans[y][k];
}
}
}
else if(S1[j].size()==3) //A.f=B
{
int z=S1[j][2]-'a'; //z表示f
for(int k=0;k<26;k++)
{
if(ans[x][k]) //x中所指向的对象 (a,b,...)
{
for(int l=0;l<26;l++)
{
tmp[k][z][l]|=ans[y][l]; //对每一个成员变量进行赋值
}
}
}
}
else //A=B.f
{
int z=S2[j][2]-'a'; //z表示f
for(int k=0;k<26;k++)
{
if(ans[y][k]) //y中所指向的对象
{
for(int l=0;l<26;l++)
{
ans[x][l]|=tmp[k][z][l]; //对每一个变量进行赋值
}
}
}
}
}
}
for(int i=0;i<26;i++)
{
printf("%c: ",i+'A');
for(int j=0;j<26;j++)
{
if(ans[i][j]==1)
printf("%c",j+'a');
}
cout<<endl;
}
return 0;
}
五：参考博客
https://blog.csdn.net/Luowaterbi/article/details/107733386
https://blog.csdn.net/qq_43680965/article/details/107743465
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
