A - 英桀的位次
给出一张7×7的表格，>表示横轴所对应的位次大于纵轴对应的位次。因此横轴的>越少，表示位次比它高的也就越少，其本身的位次也就越高。不难发现Elysia的位次最高，Su的位次最低。
#include<bits/stdc++.h>
using namespace std;
int main(){
printf("Elysia\nKevin\nAponia\nEden\nVILL-V\nKalpas\nSu\n");
return 0;
}
B - 简单字符串
将一个字符串（长度小于3×105）分为四段，每段可以为空，要求第一段的正序和第三段的倒序相同，并且第四段是个回文串，在满足前两个要求下，使得第二段的长度最小，求出第二段的最小长度。
如果枚举第一段再去找是否存在其反转，还要去判断尾串是否回文，显然复杂度太大。考虑枚举出尾串是回文串的所有情况，只要预处理出正序和倒序的哈希值便可O(1)判断是否回文，然后二分剩余字符串的长度，去判断该长度下前缀的正序哈希值和后缀的逆序哈希值是否相等，复杂度O(
n
l
o
g
n
nlogn
nlogn)。这题我底数选的是131，模数选的是109+7，据说这样造成哈希冲突的概率较小，这题单哈希也没被卡。
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int M = 3e5+10;
const int base = 131;
const int mod = 1000000007;
int n,hashs[M],hasht[M],p[M];
char s[M],t[M];
signed main(){
while(cin>>n){
p[0]=1;
scanf("%s",s+1);
n= strlen(s+1);
int ans=mod;
for(int i=1;i<=n;i++){
hashs[i]=(hashs[i-1]*base+s[i]-'a')%mod;
hasht[i]=(hasht[i-1]*base+s[n-i+1]-'a')%mod;
p[i]=p[i-1]*base%mod;
}
for(int len=0;len<=n;len++){
if((hashs[n]-hashs[n-len]*p[len]%mod+mod)%mod==hasht[len]){
int l=0,r=(n-len)/2,mid;
while(l<=r){
mid=(l+r)>>1;
if(hashs[mid]==(hasht[len+mid]-hasht[len]*p[mid]%mod+mod)%mod){
l=mid+1;
}
else r=mid-1;
}
ans=min(ans,n-2*r-len);
}
}
cout<<ans<<'\n';
}
return 0;
}
C - 胖头鱼与取石子游戏(Ⅱ)
给出三堆石子x,y,z（1≤x,y,z≤109），两人轮流操作，每次可以选择一堆石子扔掉，并将在剩余的两堆中选择一堆，将其分为两非空堆，谁无法操作谁就输了。
显然必败态为1 1 1这种情况。比赛时没有什么特别的思路，于是就写了一个程序暴力跑出石子数小于10的所有情况，不难发现如果三堆石子消去最大公因子后都为奇数，那么先手必败，否则后手必败。
打表程序
#include<bits/stdc++.h>
using namespace std;
int dfs(int a,int b,int c){
if(a==1&&b==1&&c==1){
return 0;
}
if(b>1){
for(int i=1;i<=b-1;i++){
if(!dfs(i,b-i,c)) return 1;
if(!dfs(a,b-i,i)) return 1;
}
}
if(c>1){
for(int i=1;i<=c-1;i++){
if(!dfs(i,b,c-i)) return 1;
if(!dfs(a,i,c-i)) return 1;
}
}
if(a>1){
for(int i=1;i<=a-1;i++){
if(!dfs(a-i,i,c)) return 1;
if(!dfs(a-i,b,i)) return 1;
}
}
return 0;
}
int main()
{
int t=10;
for(int i=1;i<=t;i++){
for(int j=i;j<=t;j++){
for(int k=j;k<=t;k++){
cout<<i<<' '<<j<<' '<<k<<':'<<" ";
if(dfs(i,j,k)) cout<<"first win"<<'\n';
else cout<<"second win"<<'\n';
}
}
}
return 0;
}
AC代码
#include<bits/stdc++.h>
using namespace std;
int x,y,z,g;
int main()
{
while(cin>>x>>y>>z){
g=__gcd(x,__gcd(y,z));
x/=g;y/=g;z/=g;
if(x%2==1&&y%2==1&&z%2==1) puts("LY");
else puts("PTY");
}
return 0;
}
D - wzy的考研
由于每个『高树』的血量都很小，所以只需要暴力求出每个『高树』血量消耗为0所需要的时间即可。
#include<bits/stdc++.h>
using namespace std;
const int M = 2e5+10;
int n,h[5],t[5],hp[M],ans;
int work(int k){
int tt=0,sum=0;
for(int i=1;;i++){
if(i%3==1){
sum+=h[1];
tt+=t[1];
if(sum>=k) break;
}
if(i%3==2){
sum+=h[2];
tt+=t[2];
if(sum>=k) break;
}
if(i%3==0){
sum+=h[3];
tt+=t[3];
if(sum>=k) break;
}
}
return tt;
}
int main(){
cin>>n;
for(int i=1;i<=3;i++) cin>>h[i];
for(int i=1;i<=3;i++) cin>>t[i];
for(int i=1;i<=n;i++){
cin>>hp[i];
ans+=work(hp[i]);
}
cout<<ans<<'\n';
return 0;
}
E - wzy的ICPC
看到题目的第一眼感觉和P1721特别像，细看发现其实是P1721的弱化版。记录下每一题是否AC（因为如果AC了再次提交无论对错都不再累加罚时），每一题错的次数，总AC数，总罚时。每次操作前判断该题是否AC，如果已经AC了无需做任何操作。如果未AC，并且提交正确，那么标记为AC，总AC数++，总罚时+=该题错误次数*30。如果提交错误，那么该题错误次数++。最后根据题目要求排序即可。
#include<bits/stdc++.h>
using namespace std;
const int M = 5050;
struct Node{
int alltime,isac[510],wrongnum[510],passnum,id;
}a[M];
int n,m,T,q;
bool cmp(const Node &A,const Node &B){
if(A.passnum!=B.passnum) return A.passnum>B.passnum;
if(A.alltime!=B.alltime) return A.alltime<B.alltime;
return A.id<B.id;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int id,num,time,op;
cin>>n>>m>>T;
cin>>q;
for(int i=1;i<=n;i++) a[i].id=i;
while(q--){
cin>>id>>num>>time>>op;
if(op==1){
if(!a[id].isac[num]){
a[id].isac[num]=1;
a[id].alltime+=a[id].wrongnum[num]*30+time;
a[id].passnum++;
}
}
else{
if(!a[id].isac[num]){
a[id].wrongnum[num]++;
}
}
}
sort(a+1,a+1+n,cmp);
int ans=0;
for(int i=1;i<=n;i++){
if(a[i].passnum) ++ans;
}
cout<<ans<<'\n';
for(int i=1;i<=n;i++){
if(a[i].passnum){
cout<<a[i].id<<' '<<a[i].passnum<<' '<<a[i].alltime<<'\n';
}
}
return 0;
}
F - 胖头鱼与哈希冲突
题意很简明，给你底数和模数，让你构造两个不同的字符串，使得它们在该底数和模数下的哈希值是相等的。良心的出题人还提供了生日悖论的暗示，大大降低了该题的难度。23人里出现两人同一天生日的概率就达到了50%，60人以上时出现两人同一天生日的概率已经接近100%了。365天里出现同一天生日类比于一个模数下出现相同的哈希值。所以我们只需要不断生成新的字符串，记录哈希值，并且判断该哈希值是否出现过，出现过则输出答案，未出现过则记录答案，反复此操作直至找到答案。根据题面给出的公式计算得出：在109范围内随机105个数出现相同的概率接近100%。所以暴力去找并不会超时。记得每次生成的字符串不能太短，否则哈希值可能无法突破模数，最终导致数据构不成随机分布。当然也不能太长，否则容易超时。
#include<bits/stdc++.h>
#define int long long
using namespace std;
int base,mod;
unordered_map<int,string>mp;
string s="abcdefghijklmnopqrstuvwxyz";
signed main(){
srand(time(0));
while(cin>>base>>mod){
mp.clear();
while(1){
int h=0;
string t="";
for(int i=1;i<=20;i++){
int num=rand()%26;
t+=s[num];
h=(h*base%mod+num+1)%mod;
}
if(mp[h].empty()) mp[h]=t;
else if(mp[h]!=t){
cout<<mp[h]<<'\n'<<t<<'\n';
break;
}
}
}
return 0;
}
G - 验题组的gcd
给你一个序列，将这个序列分成两个序列（可以为空），使得两个序列的最大公约数的和最大。由于一个数与一个非本身的数取GCD之后，一定会小于等于该数的一半。所以我们尽量要将大一点的数单独放一个序列，比如1 4 8，应该让8单独为一个序列，1 4为一个序列。但是很快能找到反例，比如4 7 8就应该4 8为一个序列，7单独为一个序列。所以我们选择将每个数都单独为一个序列计算一次，维护一下最大值即可。相同的数肯定是要放在一起的，比如4 7 7 8，那么肯定是4 8放一起，7 7放一起。因此一个数出现多少次并不会对答案造成影响。但是有一种情况除外，就是序列所有的数都一样的。比如5 5 5，按照上述解法，分成的序列为[5,5,5]和[]，此时算出的答案为5，而正解应该是分为[5,5]和[5]，所以这种情况要留出一个数单独构成一个序列。由于GCD具有结合律，所以直接维护前缀与后缀的GCD即可。
#include<bits/stdc++.h>
using namespace std;
const int M = 1e5+10;
int n,a[M],p[M],s[M],ans;
int GCD(int a,int b){return b?GCD(b,a%b):a;}
int main(){
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1,a+1+n);
int t = unique(a+1,a+1+n)-a-1;
if(t==1){
printf("%d\n",2*a[1]);
return 0;
}
for(int i=1;i<=n;i++) p[i]=GCD(p[i-1],a[i]);
for(int i=n;i>=1;i--) s[i]=GCD(s[i+1],a[i]);
for(int i=1;i<=n;i++) ans=max(ans,a[i]+GCD(p[i-1],s[i+1]));
cout<<ans<<endl;
return 0;
}
H - 希儿
求 ∑ i = 1 n a i x i = s \sum_{i=1}^na_ix_i=s ∑i=1naixi=s 无自然数解的最小正整数s，若不存在输出-1。先考虑 a i a_i ai均为正整数的情况，既然解是自然数，除去 x i x_i xi均为0的情况， ∑ i = 1 n a i x i \sum_{i=1}^na_ix_i ∑i=1naixi一定大于等于min{ a i a_i ai}。如果min{ a i a_i ai}>1，那么显然1无法被表示。如果存在某项 a k = 1 a_k=1 ak=1，那么只需令 x k x_k xk为全体自然数，其余 x i x_i xi为0，此时 ∑ i = 1 n a i x i \sum_{i=1}^na_ix_i ∑i=1naixi可取到任意正整数。如果 a i a_i ai=0，那么这一项可以忽略，因为无论 x i x_i xi取什么乘积都为0。如果 a i a_i ai恒为0，那么 ∑ i = 1 n a i x i \sum_{i=1}^na_ix_i ∑i=1naixi=0，此时1依旧无法被表示。因此如果出现 a i a_i ai=1，就输出-1，否则输出1。
#include<bits/stdc++.h>
using namespace std;
const int M = 1e5+10;
int n,a[M],flag;
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
if(a[i]==1) flag=1;
}
if(flag) printf("-1\n");
else printf("1\n");
return 0;
}
I - 胖头鱼的题
给定一个长度为n序列，操作次数m和整数X，每次操作给定一个正整数
c
i
c_i
ci，表示把序列从
c
i
c_i
ci处切开，要你求出每次操作后所有所有子序列的子区间和中与X差的绝对值的最小值。
考虑从后往前做，把切开序列变成合并序列，采用启发式合并，维护前缀和，时间复杂度O(
n
l
o
g
2
n
nlog^2n
nlog2n)
#include<bits/stdc++.h>
#define int long long
using namespace std;
typedef long long ll;
const int inf = 100000000000;
const int M = 1e5+10;
struct Node{
int ls,rs,cnt,maxx,minn;
}t[M<<6];
int sum[M],num[M],res[M],X,ans;
int f[M],leftmost[M],c[M],root[M],n,m,tot,ban[M];
int find(int x){
if(x==f[x]) return x;
return f[x]=find(f[x]);
}
int merge(int x,int y,int l,int r)
{
if (!x) return y;
if (!y) return x;
t[x].minn=min(t[x].minn,t[y].minn);
t[x].maxx=max(t[x].maxx,t[y].maxx);
if (l==r) return x;
int mid=(l+r)>>1;
t[x].ls=merge(t[x].ls,t[y].ls,l,mid);
t[x].rs=merge(t[x].rs,t[y].rs,mid+1,r);
return x;
}
void update(int &o,int l,int r,int x)
{
int now=++tot;t[now]=t[o];o=now;
t[o].maxx=max(t[o].maxx,x);
t[o].minn=min(t[o].minn,x);
if (l==r) return;
int mid=(l+r)>>1;
if (x<=mid) update(t[o].ls,l,mid,x);
else update(t[o].rs,mid+1,r,x);
}
int query(int o,int l,int r,int x)
{
if (!o) return inf;
if (l==r) return 0;
int mid=(l+r)>>1;
if (x<=mid) return min(query(t[o].ls,l,mid,x),t[t[o].rs].minn-x);
else return min(query(t[o].rs,mid+1,r,x),x-t[t[o].ls].maxx);
}
void work(int mid)
{
int l=leftmost[mid],r=find(mid+1);
f[mid]=r;leftmost[r]=l;
if(mid-l+1<=r-mid)
{
for(int i=l-1;i<mid;i++)
{
ans=min(ans,query(root[r],-inf,inf,sum[i]+X));
ans=min(ans,abs(sum[r]-sum[i]-X));
}
}
else
{
for(int i=mid+1;i<=r;i++)
{
ans=min(ans,query(root[mid],-inf,inf,sum[i]-X));
ans=min(ans,abs(sum[i]-sum[l-1]-X));
}
}
root[r]=merge(root[mid],root[r],-inf,inf);
update(root[r],-inf,inf,sum[mid]);
}
signed main()
{
scanf("%lld%lld%lld",&n,&m,&X);
for (int i=1;i<=n;i++){
scanf("%lld",&num[i]);
sum[i]=sum[i-1]+num[i];
}
for (int i=1;i<=n;i++){
f[i]=leftmost[i]=i;
root[i]=0;
}
for (int i=1;i<=m;i++){
scanf("%lld",&c[i]);
ban[c[i]]=1;
}
ans=inf;
for(int i=1;i<=n;i++) ans=min(ans,abs(num[i]-X));
t[0].minn=inf;t[0].maxx=-inf;
for(int i=1;i<n;i++){
if(!ban[i]) work(i);
}
for(int i=m;i;i--){
res[i]=ans;
work(c[i]);
}
for(int i=1;i<=m;i++) printf("%lld\n",res[i]);
return 0;
}
J - ccr的幼儿圆
推出公式后直接求解即可。
#include<bits/stdc++.h>
using namespace std;
int n,C,D,E,ans;
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>C>>D>>E;
ans=max(ans,(C*C+D*D-4*E)/4);
}
cout<<ans<<'\n';
return 0;
}
K - 数学题都不会还守护什么世界
给你一个正整数n，让你去找最小的正整数x，使得对于任意1≤i,j,k≤n，x都无法表示成i*j*k的形式。首先x肯定要比n大，因此从n+1开始考虑。如果x是个质数，那么只能表示成1*1*x的形式，而x是大于n的，所以大于n的最小质数是个备选答案。对于任意一个合数x，它能被表示成 1 ∗ p ∗ x p 1*p*\frac{x}{p} 1∗p∗px(p ≠ \neq = 1)的形式，而p最小为2，因此想要x无法被表示， x 2 \frac{x}{2} 2x 就要大于n，x要大于2n。而根据切比雪夫定理可知，在区间(n,2n)之间必定存在一个质数。所以这题的两个备选答案为在区间(n,2n)选一个最小的质数或者在区间(2n,+∞)选一个合数。由于题目要求是最小的正整数，所以肯定是最小的质数。由于数据范围比较小，因此就算试除法去判质数也不会超时。
#include<bits/stdc++.h>
using namespace std;
int n;
int isprime(int k){
for(int i=2;i<=k/i;i++){
if(k%i==0) return 0;
}
return 1;
}
int main()
{
cin>>n;
for(int i=n+1;;i++){
if(isprime(i)){
printf("%d\n",i);
break;
}
}
return 0;
}
L - 凌音的废题
给定n个位置，每个位置可以填 0 或 1 ，问有多少种填法使得连续的两个 1 的个数大于连续两个 0 的个数。没什么思路，考虑打表找规律。最终找到的规律是 2 n − 1 − C n − 2 ⌊ n − 2 2 ⌋ 2^{n-1}-C_{n-2}^{\lfloor \frac{n-2}{2} \rfloor} 2n−1−Cn−2⌊2n−2⌋，n=1的时候特判一下即可。
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int mod = 1e9+7;
const int M = 1e6+10;
int fac[M],n;
int ksm(int a,int b){
int res=1;
while(b){
if(b&1) res=res*a%mod;
a=a*a%mod;
b>>=1;
}
return res;
}
int Combine(int a,int b){
return fac[a]*ksm(fac[b],mod-2)%mod*ksm(fac[a-b],mod-2)%mod;
}
signed main(){
fac[0]=1;
for(int i=1;i<=1e6;i++){
fac[i]=fac[i-1]*i%mod;
}
while(cin>>n){
if(n==1){
cout<<0<<endl;
continue;
}
cout<<(ksm(2,n-1)- Combine(n-2,(n-2)/2)+mod)%mod<<'\n';
}
return 0;
}
M - 泉之精灵的旅行
有 n 个点，编号为 1 ~ n ，给出起点 s 和终点 t ，每次可以移动到相邻的点或者发动技能穿梭到 1 号点或者 n 号点，并且每个点只能到一次，问最少需要发动多少次技能，无法达到输出-1。
细节比较多，比如起点和终点相同的时候，如果n≠1就应该输出-1，如果n=1应该输出0。需要讨论的情况也比较多，比如 s 和 t 相邻的时候，s 和 t 在首尾的时候。
#include<bits/stdc++.h>
using namespace std;
int n,s,t;
int main(){
cin>>n>>s>>t;
if(n==1&&s==1&&t==1){
puts("0");
return 0;
}
if(s==t){
puts("-1");
return 0;
}
if(s==1&&t==n || s==n&&t==1){
puts("0");
return 0;
}
if(s==t+1||t==s+1){
puts("1");
return 0;
}
if(s==1 || s==n){
puts("1");
return 0;
}
puts("2");
return 0;
}
扫一扫
1812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
