2018山东省赛题目整理—5月23日

最新推荐文章于 2024-11-25 19:34:17 发布

原创最新推荐文章于 2024-11-25 19:34:17 发布 · 290 阅读

0 ·

CC 4.0 BY-SA版权

本文精选了几道典型的算法竞赛题目并提供了详细的解题思路及代码实现，包括最小生成树问题、字符串转换问题、四元组计数问题等，通过这些题目帮助读者理解贪心算法、容斥原理的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

欠了一大堆题目要整理都不知到要从哪里开始了。慢慢补上吧。

C题—Cities

题意：给出若干个城市的权值，求把它们连起来最少花费（花费=一条边连得两个城市权值）。

看似是最小生成树，其实是贪心更好写，权值最小的那个城市，用此城市连其他所有。

ll a[100005];
ll n;
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
ll minn=99999999;
ll sum=0;
scanf("%lld",&n);
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
if(a[i]<minn) minn=a[i];
sum+=a[i];
}
sum=sum-minn;
sum=sum+(n-1)*minn;
cout<<sum<<endl;
}

}

A题—Anagram

题意：题目给出两个字符串A、B，这两个字符串都由'A'-'Z'构成，字符串X是字符串B任意颠倒字符顺序构成的，求由字符串A转变到字符串X的最少操作数，如A->B，1步；B->A，25步（可以看成Z、A相连成环）。

思路：还是贪心，

先将字符串A、B分别排序，如果a[i]<=b[j]依次寻找距离字符a[i]最近的字符b[j],如果a[i]>b[j],则将剩下的配对（这里不需要考虑配对的次序）

char s1[100],s2[100];
int a[100],b[100];
int vis[100];
int solve(int x,int y)
{
if(x<=y) return y-x;
else return 26-x+y;
}
int main()
{
int len;
while(scanf("%s%s",s1,s2)!=EOF)
{
len=strlen(s1);
int i,j;
for(i=0;i<len;i++)
{
a[i+1]=s1[i]-'A'+1;
b[i+1]=s2[i]-'A'+1;
}
sort(a+1,a+1+len);
sort(b+1,b+1+len);
int ans=0;
memset(vis,0,sizeof(vis));
for(i=1;i<=len;i++)
{
int flag=0;
for(j=1;j<=len;j++)
{
if(!vis[j]&&b[j]>=a[i])
{
vis[j]=1;
ans=ans+solve(a[i],b[j]);
flag=1;
break;
}
}
if(!flag)
{
for(j=1;j<=len;j++)
{
if(!vis[j])
{
vis[j]=1;
ans=ans+solve(a[i],b[j]);
break;
}
}
}
}
cout<<ans<<endl;
}

}

F题—Four-tuples

题意：给出四个区间，问分别从四个区间中取出一个数，满足x1!=x2,x2!=x3,x3!=x4,x4!=x1，的情况有多少种。

来自：https://blog.youkuaiyun.com/MIECZ/article/details/80279668

1.先将四个区间长度的乘积作为答案
2.分别减去 x1=x2,x2=x3,x3=x4,x4=x1 四种情况的组合数量（每种情况中未提及的变量在其区间中任选，即统计答案时直接乘区间长度）
3.因为减去 x1=x2 和 x2=x3 时会重复减去 x1=x2=x3,x1=x2=x3 的情况，所以要加回来
类似的还有 x1=x2=x4, x2=x3=x4, x1=x3=x4, x1=x2=x3,x1=x2且x3=x4, x2=x3且x1=x4

4.第一步的答案中应该减去1个x1=x2=x3=x4,但是在第二步中减去了4个，第三步中又加了6个，所以总共加了2个，最终应该减去3个x1=x2=x3=x4的情况

这道题补题的时候有讨论了好久，主要是在那个对边的情况没考虑到，果然是我对容斥原理的理解深度不够，容斥原理不是简单的奇加偶减，而是始终补缺减余。

这确实是一道好题，还是我太菜了。

const ll mod=1e9+7;
int main()
{
ll n,l1,l2,l3,l4,r1,r2,r3,r4,tp1l,tp2l,tp1r,tp2r,ans;
scanf("%lld\n",&n);
while(n--&&scanf("%lld%lld%lld%lld%lld%lld%lld%lld",&l1,&r1,&l2,&r2,&l3,&r3,&l4,&r4)!=EOF)
{
ans=(r1-l1+1)*(r2-l2+1)%mod;
ans=ans*(r3-l3+1)%mod;
ans=ans*(r4-l4+1)%mod;
//1==2
tp1l=max(l1,l2);
tp1r=min(r1,r2);
if(tp1l<=tp1r)
ans=((ans-(tp1r-tp1l+1)*(r3-l3+1)%mod*(r4-l4+1)%mod)%mod+mod)%mod;
//2==3
tp1l=max(l3,l2);
tp1r=min(r3,r2);
if(tp1l<=tp1r)
ans=((ans-(tp1r-tp1l+1)*(r1-l1+1)%mod*(r4-l4+1)%mod)%mod+mod)%mod;
//3==4
tp1l=max(l3,l4);
tp1r=min(r3,r4);
if(tp1l<=tp1r)
ans=((ans-(tp1r-tp1l+1)*(r1-l1+1)%mod*(r2-l2+1)%mod)%mod+mod)%mod;
//4==1
tp1l=max(l1,l4);
tp1r=min(r1,r4);
if(tp1l<=tp1r)
ans=((ans-(tp1r-tp1l+1)*(r3-l3+1)%mod*(r2-l2+1)%mod)%mod+mod)%mod;

//1==2 2==3
tp1l=max(l1,max(l3,l2));
tp1r=min(r1,min(r3,r2));
if(tp1l<=tp1r)
ans=(ans+(tp1r-tp1l+1)*(r4-l4+1)%mod)%mod;

//1==2 3==4
tp1l=max(l1,l2);
tp1r=min(r1,r2);
tp2l=max(l3,l4);
tp2r=min(r3,r4);
if(tp1l<=tp1r&&tp2l<=tp2r)
ans=(ans+(tp1r-tp1l+1)*(tp2r-tp2l+1)%mod)%mod;

//1==2 4==1
tp1l=max(l1,max(l4,l2));
tp1r=min(r1,min(r4,r2));
if(tp1l<=tp1r)
ans=(ans+(tp1r-tp1l+1)*(r3-l3+1)%mod)%mod;
//2==3 3==4
tp1l=max(l4,max(l3,l2));
tp1r=min(r4,min(r3,r2));
if(tp1l<=tp1r)
ans=(ans+(tp1r-tp1l+1)*(r1-l1+1)%mod)%mod;
//2==3 1==4
tp1l=max(l3,l2);
tp1r=min(r3,r2);
tp2l=max(l1,l4);
tp2r=min(r1,r4);
if(tp1l<=tp1r&&tp2l<=tp2r)
ans=(ans+(tp1r-tp1l+1)*(tp2r-tp2l+1)%mod)%mod;

//3==4 4==1
tp1l=max(l4,max(l3,l1));
tp1r=min(r4,min(r3,r1));
if(tp1l<=tp1r)
ans=(ans+(tp1r-tp1l+1)*(r2-l2+1)%mod)%mod;

//1==2==3==4
tp1l=max(l4,max(max(l2,l3),l1));
tp1r=min(r4,min(min(r2,r3),r1));
if(tp1l<=tp1r)
ans=((ans-(tp1r-tp1l+1)*3)%mod+mod)%mod;
printf("%lld\n",ans);
}
return 0;

}

G题—Games

题意：给n堆石子，要从这n堆石子里删去x堆，(0<=x<=d)，使得 Bob（后手）赢，求总方案数。

用到了一点Nim博弈的知识。实际上是背包。不过这道题注意卡内存，用int。

设dp[ i ] [ j ] [ k ]代表在前 i 堆石子，去掉 j 堆的异或结果为k的方案数。
那么动态转移方程为：

dp[i][j][k]=(dp[i-1][j][k]+dp[i-1][j-1][k^a[i]])

const long long mod=1e9+7;
int a[1002],dp[1002][12][1205];
int sum;
int main()
{
int T,n,d;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&d);
sum=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
sum^=a[i];
}
memset(dp,0,sizeof(dp));
for(int i=0;i<=n;i++) dp[i][0][0]=1;
ll ans=0;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=d;j++)
{
for(int k=0;k<=1204;k++)
{
dp[i][j][k]=dp[i-1][j-1][(k^a[i])]+dp[i-1][j][k];
if(dp[i][j][k]>=mod) dp[i][j][k]-=mod;
}
if(i==n)
{
ans=ans+dp[i][j][sum];
if(ans>=mod) ans-=mod;
}
}
}
ans=(ans+dp[n][0][sum])%mod;
printf("%lld\n",ans);
}

}

E—Sequence

题意：给你一个长度为n(n<=1e6)的整数序列，定义“好数”：存在下标比它小的数，值也严格小于它。

你现在必须要删除且只能删除一个数，使删除后好数数量最多，如果有多个答案，输出最小的那个。

思路：

删除一个好数，则总的好数数量将减少一个(因为删除它后能影响到的好数仅有它自己)；

删除一个不好数，考虑删除这个不好数后能影响到的好数有几个，那么总的好数数量就减少几个；(被它所影响到的好数

因此维护一个前缀最小值和次小值就可以了。

#define inf 0x3f3f3f3f
ll a[1000010];
ll first[1000010];
ll second[1000010];
bool flag[1000010];
ll cnt[1000010];

int main()
{
ll t;
scanf("%lld",&t);
while(t--)
{
ll n;
scanf("%lld",&n);
ll now_min=inf;
ll pre_min=inf;
for(ll i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
first[i]=now_min;//前缀最小
second[i]=pre_min;//前缀次小
if(a[i]<=now_min) {pre_min=now_min; now_min=a[i];}
else {if(a[i]<pre_min) pre_min=a[i];}
}
for(ll i=1;i<=n;i++)
{
if(a[i]<=first[i]) flag[i]=1;//坏数
else flag[i]=0;//好数
}
ll k;
for(ll i=1;i<=n;i++)
{
if(flag[i]==1)//坏数
{
k=i;
cnt[k]=0;
}
else if(flag[i]==0)//好数
{
if(a[i]<=second[i]) cnt[k]++;
}
}
ll ans=inf;
for(ll i=1;i<=n;i++)
{
if(flag[i]==1&&cnt[i]==0) ans=min(ans,a[i]);
}
if(ans==inf)
{
for(ll i=1;i<=n;i++)
{
if(flag[i]==0) ans=min(ans,a[i]);
else if(cnt[i]==1) ans=min(ans,a[i]);
}
}
printf("%lld\n",ans);
}
return 0;
}