第十四届蓝桥杯大赛软件赛省赛

第十四届蓝桥杯大赛软件赛省赛

2.日期统计

小蓝现在有一个长度为 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

现在他想要从这个数组中寻找一些满足以下条件的子序列：

1. 子序列的长度为 8；
2. 这个子序列可以按照下标顺序组成一个 yyyymmdd 格式的日期，并且

要求这个日期是 2023 年中的某一天的日期，例如 20230902，20231223。
yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
请你帮小蓝计算下按上述条件一共能找到多少个不同的 2023 年的日期。
对于相同的日期你只需要统计一次即可。
本题的结果为一个整数，在提交答案时只输出这个整数，输出多余的内容将无法得分。

---

枚举2023年的每一个日期，去字符串中判断是否合法

#include <bits/stdc++.h>
using namespace std;
int months[] = 
{
    0,31,28,31,30,31,30,31,31,30,31,30,31
};
int cnt;

string s = "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";

bool check_date(string date)
{
    int idx = 0;
    for(int i = 0; i < s.size(); i ++)
    {
    	if(s[i] == date[idx])
    	{
    		idx ++;
    		if(idx >= 8)
    			return true;
		}
	}
    return false;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    for(int month = 1; month <= 12; month ++)
    {
        for(int day = 1; day <= months[month]; day ++)
        {
            string date = to_string(20230000 + month * 100 + day);
//            cout << date << endl;
            if(check_date(date))
                cnt ++;
        }
    }
    cout << cnt << endl;
    return 0;
}

答案：235

---

2.01串的熵

对于一个长度为 n 的 01 串 S = x1x2x3…xn.
香农信息熵的定义为：
。
其中 p(0), p(1) 表示在这个 01 串中 0 和 1 出现的占比。
比如，对于S = 100 来说，信息熵 H(S ) = - 1/3 log2(1/3) - 2/3 log2(2/3) - 2/3 log2(2/3) = 1.3083。
对于一个长度为23333333 的 01 串，如果其信息熵为 11625907.5798，且 0 出现次数比 1 少，那么这个01 串中 0 出现了多少次？
本题的结果为一个整数，在提交答案时只输出这个整数，输出多余的内容将无法得分。

#include <bits/stdc++.h>
using namespace std;
const int m = 23333333;
double p0, p1;
double hs = 11625907.5798;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    double hs_cal = 0;//存储计算出来的串熵
    for(int i = 0; i < m / 2; i ++)//0出现次数比1少只要枚举一半
    {
        p0 = i * 1.0 / m;
        p1 = (m - i) * 1.0 / m;
//        cout << p0 << " " << p1 << endl;
        hs_cal = i * 1.0 * p0 * (log(p0)/log(2)) + (m - i) * 1.0 * p1 * (log(p1)/log(2));
        if(fabs(hs_cal + hs) < 1e-4)
        {
            cout << i << endl;
            return 0;
        }
    }
}

答案：11027421

---

## [1.冶炼金属](https://www.lanqiao.cn/problems/3510/learning/?page=1&first_category_id=1&name=冶炼)

题目描述

小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。
这个炉子有一个称作转换率的属性 V，V 是一个正整数，
这意味着消耗 V 个普通金属 O 恰好可以冶炼出一个特殊金属 X。
当普通金属 O 的数目不足 V 时，无法继续冶炼。
现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，
这表示本次投入了 A 个普通金属O，最终冶炼出了 B 个特殊金属X。
每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。
根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少。
题目保证评测数据不存在无解的情况。

输入格式

第一行一个整数 N，表示冶炼记录的数目。
接下来输入 N 行，每行两个整数 A、B，含义如题目所述。
对于 30% 的评测用例，1 ≤ N ≤ 100。
对于 60% 的评测用例，1 ≤ N ≤ 1000。
对于 100% 的评测用例，1 ≤ N ≤ 10000，1 ≤ B ≤ A ≤ 1,000,000,000。

输出格式

输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。

输入样例 复制

3
75 3
53 2
59 2

输出样例 复制

20 25

数据范围与提示

当 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 值了。

#include <bits/stdc++.h>
using namespace std;
int Vmax = 0x3f3f3f3f, Vmin = 0;
int n;
int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n;
    while(n --)
    {
        int a, b;
        cin >> a >> b;
        Vmax = min(Vmax, a / b);
        Vmin = max(Vmin, (a / (b + 1) + 1));
    }
    cout << Vmin << " " << Vmax << endl;
    return 0;
}

---

1.飞机降落

N 架飞机准备降落到某个只有一条跑道的机场。
其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间。
即它最早可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。
降落过程需要Li个单位时间。
一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落。
但是不能在前一架飞机完成降落前开始降落。
请你判断 N 架飞机是否可以全部安全降落。

输入格式

输入包含多组数据。
第一行包含一个整数 T ，代表测试数据的组数。
对于每组数据，第一行包含一个整数 N 。
以下 N 行，每行包含三个整数：Ti，Di 和Li。
对于 30% 的数据，N ≤ 2。
对于 100% 的数据，1 ≤ T ≤ 10，1 ≤ N ≤ 10，0 ≤ Ti,Di,Li ≤ 100,000。

输出格式

对于每组数据，输出 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

数据范围与提示

对于第一组数据:

• 安排第3 架飞机于0 时刻开始降落，20 时刻完成降落。
• 安排第2 架飞机于20 时刻开始降落，30 时刻完成降落。
• 安排第1 架飞机于30 时刻开始降落，40 时刻完成降落。

对于第二组数据，无论如何安排，都会有飞机不能及时降落。

目标很简单，至少拿30%的分数。

只考虑两架飞机的情况

#include <bits/stdc++.h>
using namespace std;
const int N = 10;
int t[N], d[N], l[N];
int T;

void solv()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++)
    {
        cin >> t[i] >> d[i] >> l[i];
    }
    if(t[1] + l[1] <= t[2] + d[2])
    {
        cout << "YES" << endl;
        return ;
    }

    if(t[2] + l[2] <= t[1] + d[1])
    {
        cout << "YES" << endl;
        return ;
    }
    cout << "NO" << endl;
    return;
}

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

正解：DFS

这道题目要求我们判断给定的飞机是否都能在它们的油料耗尽之前降落。为了寻找是否存在合法的降落序列，我们可以使用深度优先搜索（DFS）的方法，尝试所有可能的降落顺序。

首先，我们需要理解题目中的条件。每架飞机在 Ti 时刻到达机场上空，剩余油料可以维持 Di 个单位时间，降落需要 Li 个单位时间。这意味着每架飞机可以在 Ti 到 +Ti+Di 的时间段内开始降落。

然后，我们可以按照以下步骤来实现 DFS：

1. 首先，我们初始化一个布尔数组 st[] 来记录每架飞机是否已经降落。
2. 然后，我们对每架飞机尝试进行降落。这里的 “尝试” 意味着我们需要检查该飞机是否可以在当前的时间内开始降落，即它的开始降落时间是否在 Ti 到 +Ti+Di 的时间段内。如果可以，我们就让它降落，并把 st[i] 设置为 true。
3. 在一架飞机降落之后，我们递归地对剩下的飞机进行尝试。这一步就是 DFS 的主要部分，我们需要在所有的可能的降落序列中进行搜索。
4. 如果在某一步我们发现当前的飞机无法在当前的时间内开始降落，我们就返回 false，并在上一层中尝试下一架飞机。
5. 如果所有的飞机都已经降落，我们就返回 true。
6. 最后，我们对所有飞机进行尝试。如果存在至少一个可以让所有飞机都降落的序列，我们就输出 YES，否则输出 NO。

通过以上步骤，我们可以找出是否存在一个合法的降落序列，使得所有的飞机都能在它们的油料耗尽之前降落。

#include <bits/stdc++.h>
using namespace std;
const int N = 15;
int n;
int a[N], b[N], c[N];
bool st[N];

bool dfs(int u, int last, int cnt)
{
    if(b[u] < last)
        return false;
    if(cnt == n)
        return true;

    for(int i = 0; i < n; i ++)
        if(!st[i])
        {
            st[i] = true;
            if(dfs(i, max(a[u], last) + c[u], cnt + 1))
                return true;
            st[i] = false;
        }
    return false;
}

int main()
{
    int t;
    cin >> t;
    while(t --)
    {
        memset(st, 0 , sizeof st);
        cin >> n;
        for(int i = 0; i < n; i ++)
            cin >> a[i] >> b[i] >> c[i], b[i] += a[i];
        
        bool flag = false;
        for(int i = 0; i < n; i ++)
        {
            st[i] = true;
            if(dfs(i, 0, 1))
            {
                flag = true;
                break;
            }
            st[i] = false;
        }
        cout << (flag ? "YES" : "NO") << endl;
    }
    return 0;
}

---

0接龙数列

题目描述

对于一个长度为 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。
对于 20% 的数据，1 ≤ N ≤ 20。
对于 50% 的数据，1 ≤ N ≤ 10000。
对于 100% 的数据，1 ≤ N ≤ 105，1 ≤ Ai ≤ 109。
所有 Ai 保证不包含前导0。

输出格式

一个整数代表答案。

输入样例

5
11 121 22 12 2023

输出样例

1

数据范围与提示

删除 22，剩余 11, 121, 12, 2023 是接龙数列。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N];//存放数字的第一位和最后一位
int dp[N];
string s;
int n;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i ++)
    {
        cin >> s;
        int len = s.size();
        a[i] = s[0] - '0', b[i] = s[len - 1] - '0';
    }

    int res = 0;
    for(int i =1; i <= n; i ++)
    {
        int val = dp[a[i]] + 1;
        dp[b[i]] = max(dp[b[i]], val);
        res = max(res, dp[b[i]]);
    }
    cout << n - res << endl;
    return 0;
}

---

1.岛屿个数

问题描述

小蓝得到了一副大小为 M×N* 的格子地图，可以将其视作一个只包含字符 ‘0’（代表海水）和 ‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的 ‘1’ 相连接而形成。

在岛屿 A 所占据的格子中，如果可以从中选出 k 个不同的格子，使得他们的坐标能够组成一个这样的排列：(0,0),(1,1),…,(−1,−1)(x0,y0),(x1,y1),…,(xk−1,yk−1)，其中 (+1mod,+1mod)(xi*+1modk,yi+1modk) 是由(xi,yi) 通过上/下/左/右移动一次得来的 (0≤≤−1)(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

样例说明

对于第一组数据，包含两个岛屿，下面用不同的数字进行了区分：

01111
11001
10201
10001
11111

岛屿 22 在岛屿 11 的“环”内部，所以岛屿 22 是岛屿 11 的子岛屿，答案为 11。

对于第二组数据，包含三个岛屿，下面用不同的数字进行了区分：

111111
100001
020301
100001
111111

注意岛屿 33 并不是岛屿 11 或者岛屿 22 的子岛屿，因为岛屿 11 和岛屿 22 中均没有“环”。

评测用例规模与约定

对于 3030 的评测用例，1≤,≤101≤M,N≤10。

对于 100100 的评测用例，1≤≤101≤T≤10，1≤,≤501≤M,N≤50。

运行限制

语言	最大运行时间	最大运行内存
C++	2s	256M
C	2s	256M
Java	3s	256M
Python3	4s	256M
PyPy3	4s	256M
Go	4s	256M
JavaScript	4s	256M

BFS

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
//int dx[] = {-1, -1, 0, 1, 1, 1, 0, -1};
//int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int dx[ 8 ] = {0,0,1,-1,1,1,-1,-1};
int dy[ 8 ] = {1,-1,0,0,1,-1,1,-1};
int n, m, t;
string s[N];
vector<vector<bool>> vis;

bool inmap(int x, int y)
{
    if(x < 1 || x > n) return false;
    if(y < 1 || y > m)  return false;
    return true;
}

void bfs(int x, int y)
{//寻找与(x,y)联通的陆地
    queue<pair<int, int>> q;
    q.push({x, y});
    vis[x][y] = true;
    while(q.size())
    {
        x = q.front().first;
        y = q.front().second;
        q.pop();
        for(int i = 0; i < 4; i ++)
        {
            int tx = x + dx[i];
            int ty = y + dy[i];
            if(!inmap(tx, ty)) continue;
            if(s[tx][ty] != '1') continue;
            if(vis[tx][ty]) continue;
            vis[tx][ty] = true;
            q.push({tx, ty});
        }
    }
}

bool check(int x, int y)//判断(x,y)所在的联通块能否通过海水与边界相连
{
    vector<vector<bool>> st(n + 1, vector<bool>(m + 1, 0));
    queue<pair<int, int>> q;
    q.push({x, y});
    st[x][y] = true;
    
    while(q.size())
    {
        x = q.front().first;
        y = q.front().second;
        q.pop();
        if(x == 1 || x == n || y == 1 || y == m) return true;
        for(int i = 0; i < 8; i ++)
        {
            int tx = x + dx[i];
            int ty = y + dy[i];
            if(!inmap(tx, ty)) continue;
            if(s[tx][ty] != '0') continue;
            if(st[tx][ty]) continue;
            st[tx][ty] = true;
            q.push({tx, ty});
        }
    }
    return false;
}

int main()
{
	cin >> t;
	while(t --)
	{
		cin >> n >> m;
	    for(int i = 1; i <= n; i ++)
	    {
	    	cin >> s[i];
	    	s[i] = "?" + s[i];
		}
	    
	    vis = vector<vector<bool>> (n + 1, vector<bool>(m + 1, 0));
	    int ans = 0;
	    for(int i = 1; i <= n; i ++)
	    {
	        for(int j = 1; j <= m; j ++)
	        {
	            if(!vis[i][j] && s[i][j] == '1')
	            {
	                bfs(i, j);
	                if(check(i,j))
	                    ans ++;
	            }
	        }
	    }
	    cout << ans << endl;
	}
    return 0;
}

---

0子串简写

程序猿圈子里正在流行一种很新的简写方法：
对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。
例如internationalization简写成 i18n，Kubernetes 简写成 K8s, Lanqiao 简写成 L5o 等。
在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法。
长度小于 K 的字符串不允许使用这种简写。
给定一个字符串 S 和两个字符 c1 和 c2。
请你计算 S 有多少个以 c1 开头 c2 结尾的子串可以采用这种简写？

输入格式

第一行包含一个整数 K。
第二行包含一个字符串 S 和两个字符c1 和c2。
对于 20% 的数据，2 ≤ K ≤ |S| ≤ 10000。
对于 100% 的数据，2 ≤ K ≤ |S| ≤ 5 × 105。
S 只包含小写字母。c1 和 c2 都是小写字母。
|S| 代表字符串S 的长度。

输出格式

一个整数代表答案。

输入样例

4
abababdb a b

输出样例

6

数据范围与提示

符合条件的子串如下所示，中括号内是该子串：
[abab]abdb
[ababab]db
[abababdb]
ab[abab]db
ab[ababdb]
abab[abdb]

没思路，骗20%先！

#include <bits/stdc++.h>
using namespace std;
int k;
string s;
char c1,c2;

int main()
{
	int res = 0;
    cin >> k;
    cin >> s;
    cin >> c1 >> c2;
    for(int len = k; len <= s.size(); len ++)
	    for(int i = 0; i + len - 1 < s.size(); i ++)
	    {
	        if(s[i] == c1 && s[i + len - 1] == c2)
	        {
	        	res ++;
			}
	    }
    cout << res << endl;
    return 0;
}

正解：前缀和

解题思路

#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
typedef long long LL;
LL k, ans, suf[N];
string s;
char c1,c2;

int main()
{
    cin >> k >> s >> c1 >> c2;
    LL n = s.size(); s = ' ' + s;
    for(int i = n; i >= 1; i --)
        suf[i] = suf[i + 1] + (s[i] == c2);
    for(int i = 1; i + k - 1 <= n; i ++)
        if(s[i] == c1) ans += suf[i + k - 1];
    
    cout << ans << endl;
    return 0;
}

---

1.整数删除

题目描述

给定一个长度为 N 的整数数列：A1, A2, … , AN。你要重复以下操作 K 次：
每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。
并把与它相邻的整数加上被删除的数值。
输出 K 次操作后的序列。

输入格式

第一行包含两个整数 N 和 K。
第二行包含 N 个整数，A1, A2, … , AN。
对于 20% 的数据，1 ≤ K ＜ N ≤ 10000。
对于 100% 的数据，1 ≤ K ＜ N ≤ 5 × 105，0 ≤ Ai ≤ 108。

输出格式

输出 N − K 个整数，中间用一个空格隔开，代表 K 次操作后的序列。

输入样例 复制

5 3
1 4 2 8 7

输出样例 复制

17 7

数据范围与提示

数列变化如下，中括号里的数是当次操作中被选择的数：
[1] 4 2 8 7
5 [2] 8 7
[7] 10 7
17 7

---

纯模拟可过30%

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    vector<int> a;
    for(int i = 1; i <= n; i ++)
    {
        int x;
        cin >> x;
        a.push_back(x);
    }
    while(k --)
    {
        //寻找最小值
        int x = *min_element(a.begin(), a.end());
        for(int i = 0; i <= (int)a.size() - 1; i ++)
        {
            if(a[i] == x)
            {
                if(i - 1 >= 0) a[i - 1] += x;
                if(i + 1 <= (int)a.size() - 1) a[i + 1] += x;
                a.erase(a.begin() + i, a.begin() + i + 1);
                break;
            }
        }
    }
    for(int i = 0; i < (int)a.size(); i ++)
        cout << a[i] << " \n"[i == a.size() - 1];
    
    return 0;
}

---

正解：优先队列+双链表

#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
typedef long long LL;
typedef pair<LL, LL> PLL;
priority_queue<PLL, vector<PLL>,greater<PLL>> q;
LL a[N], l[N], r[N];
int n, k;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    for(int i = 1; i <= n; i ++)
    {
        cin >> a[i];
        l[i] = i - 1, r[i] = i + 1;
        q.push({a[i], i});
    }

    while(k && !q.empty())
    {
        auto t = q.top();
        q.pop();
        LL val = t.first, id = t.second;
        if(a[id] == val)
        {//可以删除
            a[l[id]] += a[id], a[r[id]] += a[id], k --;
            l[r[id]] = l[id], r[l[id]] = r[id], a[id] = 0;
        }
        else
        {
            q.push({a[id], id});
        }
    }

    for(int i = 1; i <= n; i ++)
        if(a[i])
            cout << a[i] << " ";
    return 0;
}

---

最后一题看不懂，暂时完结~