目录
试题 A: 日期统计
本题总分： 5 分
【问题描述】
小蓝现在有一个长度为 100 的数组，数组中的每个元素的值都在 0 到 9 的范围之内。数组中的元素从左至右如下所示：
5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1 0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3
现在他想要从这个数组中寻找一些满足以下条件的子序列：
- 子序列的长度为 8；
- 这个子序列可以按照下标顺序组成一个 yyyymmdd 格式的日期，并且要求这个日期是 2023 年中的某一天的日期，例如 20230902，20231223。yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
请你帮小蓝计算下按上述条件一共能找到多少个不同 的 2023 年的日期。
对于相同的日期你只需要统计一次即可。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
#include<bits/stdc++.h>
using namespace std;
int a[110],ans=0;
bool vis[20240000];
bool check(int z)
{
if(vis[z]) return false;
vis[z]=1;
int m=z/100%100;
int d=z%100;
if(m>12||m<1) return false;
if(m==1||m==3||m==5||m==7||m==8||m==10||m==12)
{
if(d>=1&&d<=31)
return true;
}
else if(m==2)
{
if(d>=1&&d<=28)
return true;
}
else if(d>=1&&d<=30)
{
return true;
}
else return false;
}
void dfs(int x,int y,int z)
{
if(x==101) return;
if(y==8)
{
if(check(z))
{
ans++;
}
return;
}
if((y==0&&a[x]==2)||
(y==1&&a[x]==0)||
(y==2&&a[x]==2)||
(y==3&&a[x]==3)||
(y==4&&a[x]>=0&&a[x]<=1)||
(y==5&&a[x]>=0&&a[x]<=9)||
(y==6&&a[x]>=0&&a[x]<=3)||
(y==7&&a[x]>=0&&a[x]<=9))
{
dfs(x+1,y+1,z*10+a[x]);
}
dfs(x+1,y,z);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for(int i=1;i<=100;i++)
{
cin>>a[i];
}
dfs(0,0,0);
printf("%d",ans);
return 0;
}试题 B: 01 串的熵
本题总分：5分
#include <bits/stdc++.h>
using namespace std;
float cal(int x) //x:0
{
float size0=(float)x/(float)23333333;
float size1=(float)(23333333-x)/(float)23333333;
return -((float)x*size0*log2(size0))-((float)(23333333-x)*size1*log2(size1));
}
int main()
{
for(int i=0;i<=23333333;i++)
{
if(abs(cal(i)-11625907.5798)<0.5)
{
printf("%d",i);
return 0;
}
}
printf("No");
return 0;
}试题 C: 冶炼金属
时间限制: 1.0 s 内存限制: 256.0MB 本题总分: 10 分
【问题描述】
小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。
现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。
根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。
【输入格式】
第一行一个整数 N，表示冶炼记录的数目。
接下来输入 N 行，每行两个整数 A、B，含义如题目所述。
【输出格式】
输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。
【样例输入】
3
75 3
53 2
59 2
【样例输出】
20 25
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
scanf("%d", &n);
int v_min = 1, v_max = 1e9;
while (n -- )
{
int a, b;
scanf("%d%d", &a, &b);
v_min = max(v_min, a / (b + 1) + 1);
v_max = min(v_max, a / b);
}
printf("%d %d\n", v_min, v_max);
return 0;
}
试题 D: 飞机降落
时间限制: 2.0 s 内存限制: 256.0MB 本题总分: 10 分
【问题描述】
N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。降落过程需要 Li个单位时间。
一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。
请你判断 N 架飞机是否可以全部安全降落。
【输入格式】
输入包含多组数据。
第一行包含一个整数 T，代表测试数据的组数。
对于每组数据，第一行包含一个整数 N。
以下 N 行，每行包含三个整数：Ti，Di 和 Li。
【输出格式】
对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。
【样例输入】
2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20
【样例输出】
YES
NO
#include<bits/stdc++.h>
using namespace std;
const int N=15;
int t,n,a[N],b[N],c[N],st[N];
bool isright(int cnt,int time)
{
if(cnt>=n)
{
return true;
}
else
{
for(int i=1;i<=n;i++)
{
if(a[i]+b[i]>=time&&!st[i])
{
st[i]=true;
if(isright(cnt+1,max(time,a[i])+c[i]))
return true;
st[i]=false;
}
}
}
return false;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin>>t;
while(t>0)
{
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
memset(st,false,sizeof(st));
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i]>>b[i]>>c[i];
}
if(isright(0,0))
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
t--;
}
return 0;
}试题 E: 接龙数列
时间限制: 1.0 s 内存限制: 256.0MB 本题总分: 15分
【问题描述】
对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。
例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。
现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？
【输入格式】
第一行包含一个整数 N。
第二行包含 N 个整数 A1, A2, . . . , AN。
【输出格式】
一个整数代表答案。
【样例输入】
5
11 121 22 12 2023
【样例输出】
1
#include<bits/stdc++.h>
using namespace std;
int dp[10],n;
//dp[y]=max(dp[y],dp[x]+1);
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++)
{
string a;
cin>>a;
int high=a[0]-'0';
int low=a[a.size()-1]-'0';
dp[low]=max(dp[low],dp[high]+1);
}
int ans=0;
for(int i=0;i<=9;i++)
{
ans=max(ans,dp[i]);
}
cout<<n-ans;
return 0;
}试题 F: 岛屿个数
时间限制: 2.0 s 内存限制: 256.0MB 本题总分: 15 分
【问题描述】
小蓝得到了一副大小为 M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和 ‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。
在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(x0, y0),(x1, y1), . . . ,(xk−1, yk−1)，其中(x(i+1)%k, y(i+1)%k) 是由 (xi, yi) 通过上/下/左/右移动一次得来的 (0 ≤ i ≤ k − 1)，此时这 k 个格子就构成了一个 “环”。如果另一个岛屿 B 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 B 视作是岛屿 A 的子岛屿。若 B 是 A 的子
岛屿，C 又是 B 的子岛屿，那 C 也是 A 的子岛屿。
请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。
【输入格式】
第一行一个整数 T，表示有 T 组测试数据。
接下来输入 T 组数据。对于每组数据，第一行包含两个用空格分隔的整数
M、N 表示地图大小；接下来输入 M 行，每行包含 N 个字符，字符只可能是‘0’ 或 ‘1’。
【输出格式】
对于每组数据，输出一行，包含一个整数表示答案。
【样例输入】
2
5 5
01111
11001
10101
10001
11111
5 6
111111
100001
010101
100001
111111
【样例输出】
1
3
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int N=55;
int T;
int m,n,ans=0;
char g[N][N];
bool st[N][N],use[N][N];
int dx1[]={0,0,1,-1};
int dy1[]={1,-1,0,0};
int dx2[]={0,0,1,1,1,-1,-1,-1};
int dy2[]={1,-1,0,1,-1,0,1,-1};
void bfs_col(int x,int y)
{
queue<PII> q;
st[x][y]=true;
q.push({x,y});
while(!q.empty())
{
auto t=q.front();
q.pop();
for(int i=0;i<4;i++)
{
int a=t.first+dx1[i],b=t.second+dy1[i];
if(a<1||a>m||b<1||b>n) continue;
if(st[a][b]) continue;
if(g[a][b]=='0') continue;
st[a][b]=true;
q.push({a,b});
}
}
}
bool bfs_sea(int x,int y)
{
memset(use,false,sizeof(use));
queue<PII> q;
if(x==1||y==m||x==1||y==n) return true;
q.push({x,y});
use[x][y]=true;
while(!q.empty())
{
auto t=q.front();
q.pop();
for(int i=0;i<8;i++)
{
int a=t.first+dx2[i],b=t.second+dy2[i];
if(a<1||a>m||b<1||b>n) continue;
if(use[a][b]) continue;
if(g[a][b]=='1') continue;
if(a==1||a==m||b==1||b==n) return true;
use[a][b]=true;
q.push({a,b});
}
}
return false;
}
void solve()
{
cin>>m>>n;
ans=0;
memset(st,false,sizeof(st));
memset(g,' ',sizeof(g));
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
cin>>g[i][j];
}
}
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
if(!st[i][j]&&g[i][j]=='1')
{
bfs_col(i,j);
if(bfs_sea(i,j))
{
ans++;
}
}
}
}
cout<<ans<<endl;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>T;
while(T)
{
solve();
T--;
}
return 0;
}
试题 G:子串简写
时间限制: 1.0 s 内存限制: 256.0MB 本题总分: 20 分
【问题描述】
程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internation-alization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简写成 K8s, Lanqiao 简写成 L5o 等。
在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。
给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头，c2 结尾的子串可以采用这种简写？
【输入格式】
第一行包含一个整数 K。
第二行包含一个字符串 S 和两个字符 c1 和 c2。
【输出格式】
一个整数代表答案。
【样例输入】
4
abababdb a b
【样例输出】
6
#include<bits/stdc++.h>
using namespace std;
long long ans;
int k;
string s;
char c1,c2;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>k>>s>>c1>>c2;
int sum_c1=0;
for(int i=k-1,j=0;i<s.size();i++,j++)
{
if(s[j]==c1) ++sum_c1;
if(s[i]==c2) ans+=sum_c1;
}
cout<<ans;
return 0;
}试题 H:整数删除
时间限制: 1.0 s 内存限制: 256.0MB 本题总分: 20 分
【问题描述】
给定一个长度为 N 的整数数列：A1, A2, . . . , AN。你要重复以下操作 K 次：每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。并把与它相邻的整数加上被删除的数值。
输出 K 次操作后的序列。
【输入格式】
第一行包含两个整数 N 和 K。
第二行包含 N 个整数，A1, A2, A3, . . . , AN。
【输出格式】
输出 N − K 个整数，中间用一个空格隔开，代表 K 次操作后的序列。
【样例输入】
5 3
1 4 2 8 7
【样例输出】
17 7
#include <iostream>
using namespace std;
#include<vector>
#include<queue>
#define int long long
const int N = 5e5 + 10;
int n, k;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> que;
int pre[N], ne[N];
int cnt[N], a[N], tmp;
signed main()
{
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> tmp;
que.push(make_pair(tmp, i));
pre[i] = i - 1;
ne[i] = i + 1;
}
while (que.size() > n - k) {
int num = que.top().first;
int id = que.top().second;
que.pop();
if (cnt[id]) {
que.push({ num + cnt[id],id });
cnt[id] = 0;
}
else {
int left = pre[id];
int right = ne[id];
cnt[left] += num;
cnt[right] += num;
ne[left] = right;
pre[right] = left;
}
}
while (!que.empty()) {
int num = que.top().first;
int id = que.top().second;
que.pop();
a[id] = num + cnt[id];
}
for (int i = 1; i <= n; i++) {
if (a[i]) {
cout << a[i] << " ";
}
}
return 0;
}试题 I: 景区导游
时间限制: 5.0 s 内存限制: 256.0MB 本题总分: 25分
【问题描述】
某景区一共有 N 个景点，编号 1 到 N。景点之间共有 N − 1 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。
小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 K 个景点：A1, A2, . . . , AK。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 K − 1 个景点。具体来说，如果小明选择跳过 Ai，那么他会按顺序带游客游览 A1, A2, . . . , Ai−1, Ai+1, . . . , AK, (1 ≤ i ≤ K)。请你对任意一个 Ai，计算如果跳过这个景点，小明需要花费多少时间在景
点之间的摆渡车上？
【输入格式】
第一行包含 2 个整数 N 和 K。
以下 N − 1 行，每行包含 3 个整数 u, v 和 t，代表景点 u 和 v 之间有摆渡车线路，花费 t 个单位时间。
最后一行包含 K 个整数 A1, A2, . . . , AK 代表原定游览线路。
【输出格式】
输出 K 个整数，其中第 i 个代表跳过 Ai 之后，花费在摆渡车上的时间。
【样例输入】
6 4
1 2 1
1 3 1
3 4 2
3 5 2
4 6 3
2 6 5 1
【样例输出】
10 7 13 14
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAX_N=1e5+1;
vector<int>E[MAX_N],W[MAX_N];
int N,K,dep[MAX_N],fa[MAX_N][21],A[MAX_N];
LL dis[MAX_N];
void dfs(int u,int Fa){
dep[u]=dep[Fa]+1;
fa[u][0]=Fa;
for(int i=1;i<=20;i++)
fa[u][i]=fa[fa[u][i-1]][i-1];
for(int i=0;i<E[u].size();i++){
int v=E[u][i],w=W[u][i];
if(v==Fa) continue;
dis[v]=dis[u]+w;
dfs(v,u);
}
}
int LCA(int u,int v){
if(dep[u]<dep[v]) swap(u,v);
for(int i=20;i>=0;i--)
if(dep[fa[u][i]]>=dep[v])
u=fa[u][i];
if(u==v) return u;
for(int i=20;i>=0;i--)
if(fa[u][i]!=fa[v][i]){
u=fa[u][i];
v=fa[v][i];
}
return fa[u][0];
}
LL path_dis(int u,int v){
if(!u || !v) return 0;
return dis[u]+dis[v]-2*dis[LCA(u,v)];
}
int main(){
ios::sync_with_stdio(0); cin.tie(0);
cin>>N>>K;
for(int i=1;i<N;++i){
int u,v,t; cin>>u>>v>>t;
E[u].push_back(v);
W[u].push_back(t);
E[v].push_back(u);
W[v].push_back(t);
}
dfs(1,0);
LL ans=0;
for(int i=1;i<=K;++i){
cin>>A[i];
ans+=path_dis(A[i],A[i-1]);
}
for(int i=1;i<=K;++i)
cout<<ans-path_dis(A[i-1],A[i])-path_dis(A[i],A[i+1])+path_dis(A[i-1],A[i+1])<<' ';
return 0;
}
试题 J: 砍树
时间限制: 1.0 s 内存限制: 256.0MB 本题总分: 25 分
【问题描述】
给定一棵由 n 个结点组成的树以及 m 个不重复的无序数对 (a1, b1), (a2, b2),. . . , (am, bm)，其中 ai 互不相同，bi 互不相同，ai , bj(1 ≤ i, j ≤ m)。小明想知道是否能够选择一条树上的边砍断，使得对于每个 (ai, bi) 满足 ai和 bi 不连通，如果可以则输出应该断掉的边的编号（编号按输入顺序从 1 开始），否则输出 -1。
【输入格式】
输入共 n + m 行，第一行为两个正整数 n，m。
后面 n − 1 行，每行两个正整数 xi，yi 表示第 i 条边的两个端点。
后面 m 行，每行两个正整数 ai，bi。
【输出格式】
一行一个整数，表示答案，如有多个答案，输出编号最大的一个。
【样例输入】
6 2
1 2
2 3
4 3
2 5
6 5
3 6
4 5
【样例输出】
4
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
vector<int>e[N],num[N];
int n,m,dep[N],s[N],fa[N][21],ans;
void dfs(int u,int Fa){
dep[u]=dep[Fa]+1;
fa[u][0]=Fa;
for(int i=1;i<=20;++i)
fa[u][i]=fa[fa[u][i-1]][i-1];
for(auto &v:e[u]){
if(v==Fa) continue;
dfs(v,u);
}
}
int LCA(int u,int v){
if(dep[u]<dep[v]) swap(u,v);
for(int i=20;i>=0;--i)
if(dep[fa[u][i]]>=dep[v])
u=fa[u][i];
if(u==v) return u;
for(int i=20;i>=0;--i)
if(fa[u][i]!=fa[v][i]){
u=fa[u][i];
v=fa[v][i];
}
return fa[u][0];
}
void dfs2(int u,int Fa){
for(int i=0;i<e[u].size();++i){
int v=e[u][i],p=num[u][i];
if(v==Fa) continue;
dfs2(v,u);
s[u]+=s[v];
if(s[v]==m) ans=max(ans,p);
}
}
int main(){
cin>>n>>m;
for(int i=1;i<n;++i){
int x,y; cin>>x>>y;
e[x].push_back(y);
num[x].push_back(i);
e[y].push_back(x);
num[y].push_back(i);
}
dfs(1,0);
for(int i=1;i<=m;++i){
int a,b; cin>>a>>b;
s[a]++; s[b]++; s[LCA(a,b)]-=2;
}
dfs2(1,0);
cout<<ans;
return 0;
}
5825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
