第十四届蓝桥杯大赛软件赛省赛C/C++大学B组（持续更新）

小蓝有一个神奇的炉子用于将普通金属 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
试题 C: 冶炼金属 4
第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组
【样例说明】
当 V = 20 时，有：⌊
75
20 ⌋ = 3，⌊
53
20 ⌋ = 2，⌊
59
20 ⌋ = 2，可以看到符合所有冶炼
记录。
当 V = 25 时，有：⌊
75
25 ⌋ = 3，⌊
53
25 ⌋ = 2，⌊
59
25 ⌋ = 2，可以看到符合所有冶炼
记录。
且再也找不到比 20 更小或者比 25 更大的符合条件的 V 值了。
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ N ≤ 102。
对于 60% 的评测用例，1 ≤ N ≤ 103。
对于 100% 的评测用例，1 ≤ N ≤ 104，1 ≤ B ≤ A ≤ 109。

他要求的是要是符合条件的最小的最大，最大的最小这样就有两根很明显的分界线，就可以用二分找到最小的最大，最大的最小

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=11000;

int a[N],b[N];//a-->b;
int n;

bool check1(int mid)
{
    for(int i=1;i<=n;i++)
    {
        if(a[i]/mid>b[i])return true;
    }
    return false;
}

int minv()
{
    int l=0,r=1e9;
    while(l+1<r)
    {
        int mid=l+r>>1;
        if(check1(mid))l=mid;
        else r=mid;
    }
    return l+1;
}

bool check2(int mid)
{
    for(int i=1;i<=n;i++)
    {
        if(a[i]/mid<b[i])return false;
    }
    return true;
}


int maxv()
{
    int l=0,r=1e9;
    while(l+1<r)
    {
        int mid=l+r>>1;
        if(check2(mid))l=mid;
        else r=mid;
    }
    return r-1;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=1;i<=n;i++)
      cin>>a[i]>>b[i];
      
    int res=maxv();
    int ans=minv();
    cout<<ans<<' '<<res<<endl;
    return 0;
}

【问题描述】
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
试题D: 飞机降落 6
第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组
0 10 20
10 10 20
20 10 20
【样例输出】
YES
NO
【样例说明】
对于第一组数据，可以安排第 3 架飞机于 0 时刻开始降落，20 时刻完成降
落。安排第 2 架飞机于 20 时刻开始降落，30 时刻完成降落。安排第 1 架飞机
于 30 时刻开始降落，40 时刻完成降落。
对于第二组数据，无论如何安排，都会有飞机不能及时降落。
【评测用例规模与约定】
对于 30% 的数据，N ≤ 2。
对于 100% 的数据，1 ≤ T ≤ 10，1 ≤ N ≤ 10，0 ≤ Ti
, Di
, Li ≤ 105。
试题 D: 飞机降落 7
第十四届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组
试题 E: 接龙数列
时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分
【问题描述】
对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且
仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。
例如 12, 23, 35, 56, 61, 11 是接

代码是全排列，枚举所有可能，然后一个个判断即可

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=15;

int n;
int t[N],d[N],l[N];
int a[N];
bool flag,st[N];

bool check()
{
    int tt=t[a[1]];//第1架飞机的上升到最高空的时间
    for(int i=1;i<=n;i++)
    {
        int idx=a[i];
        if(d[idx]+t[idx]<tt)return false; //当下一架飞机最后下落的时间比第一架第1架飞机的上升到最高空的时间小的时候直接返回false，剪枝。
        else tt=max(tt,t[idx])+l[idx]; //把下一架飞机的时间加起来
    }
    return true;
}

void dfs(int u)//全排列
{
    if(flag)return;
    if(u==n+1)
    {
        if(check())flag=true;
        return;
    }
    
    for(int i=1;i<=n;i++)
    {
        if(!st[i])
        {
            a[u]=i;
            st[i]=true;
            dfs(u+1);
            st[i]=false;
        }
    }
}


void solve()
{
    cin>>n;
     for (int i = 1; i <= n; i++) 
       cin >> t[i] >> d[i] >> l[i];
    flag=false;
    dfs(1);
    if(flag)
      cout<<"YES"<<endl;
    else 
      cout<<"NO"<<endl;
}

signed main()
{
    int T;
    cin>>T;
    while(T--)
      solve();
    return 0;
}

试题 G: 子串简写【问题描述】
程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首
尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internationalization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简
写成 K8s, Lanqiao 简写成 L5o 等。
在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法
（长度小于 K 的字符串不配使用这种简写）。
给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头
c2 结尾的子串可以采用这种简写？
【输入格式】
第一行包含一个整数 K。
第二行包含一个字符串 S 和两个字符 c1 和 c2。
【输出格式】
一个整数代表答案。
【样例输入】
4
abababdb a b
【样例输出】
6
【样例说明】
符合条件的子串如下所示，中括号内是该子串：
[abab]abdb
[ababab]db
[abababdb]
ab[abab]db
ab[ababdb]
abab[abdb]
【评测用例规模与约定】
对于 20% 的数据，2 ≤ K ≤ |S | ≤ 10000。
对于 100% 的数据，2 ≤ K ≤ |S | ≤ 5 × 105。S 只包含小写字母。c1 和 c2 都
是小写字母。
|S | 代表字符串 S 的长度。

线性dp，

定义dp[i]在长度为i到len的时候c2的个数

状态转移方程是当s[i]==c2时，dp[i]=dp[i+1]+1

当s[i]！=c2或者s[i]==c2时候都可以从dp[i]=dp[i+1]转移过来

然后根据题目含义说字串长度大于等于 K所以只要枚举左端点即可

代码：

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=510000;

string s;
char c1,c2;
int k;
int f[N];

signed main()
{
    ios::sync_with_stdio(false);
    
    cin>>k;
    cin>>s>>c1>>c2;
    int n=s.size();
    s='?'+s;
    for(int i=n;i>=1;i--)
    {
        f[i]=f[i+1];
        if(c2==s[i])f[i]=f[i+1]+1;
    }
    
    int ans=0;
    for(int i=1;i+k-1<=n;i++)
        if(s[i]==c1)ans+=f[i+k-1];
     
     cout<<ans<<endl;
    return 0;
}

试题 E: 接龙数列
时间限制: 1.0s 内存限制: 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
【样例说明】
删除 22，剩余 11, 121, 12, 2023 是接龙数列

 线性dp：

定义f[i][j]表示的是当前是第i个数字第i个数字是以j为结尾的最长接龙数列

创建一个结构体

struct node{
    int a,b;//头a，尾b
}s[N];

其中a表示当前第i个数字的头为a，尾是b

这样可以写出状态转移方程f[i][s[i].b]=max(f[i-1][s[i].a]+1,f[i][s[i].b])

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=110000;

struct node{
    int a,b;//头a，尾b
}s[N];

int n;
int f[N][14];


signed main()
{
    ios::sync_with_stdio(false);
    cin>>n;
    
    string ss;
    for(int i=1;i<=n;i++)
    {
        cin>>ss;
        s[i].a=ss[0]-'0';
        s[i].b=ss.back()-'0';
    }

    // for(int i=0;i<=10;i++)
    //     f[0][i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<10;j++)
        {
            f[i][j]=f[i-1][j];
        }
        f[i][s[i].b]=max(f[i-1][s[i].a]+1,f[i][s[i].b]);
    }
    
    int maxv=0;
    for(int i=0;i<10;i++)
          maxv=max(maxv,f[n][i]);
    cout<<n-maxv<<endl;
      
    return 0;
}