当前位置：首页 > wzjs >正文

武汉吧哒科技怎么样辽宁seo推广

wzjs 2025/7/20 3:34:00

武汉吧哒科技怎么样,辽宁seo推广,朝阳市城乡建设委员会网站和,莱芜网络推广公司哪里有试题A：日期统计【问题描述】小蓝现在有一个长度为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 …

试题A：日期统计

【问题描述】
小蓝现在有一个长度为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.这个子序列可以按照下标顺序组成一个 yyy,ymmdd 格式的日期，并且要求这个日期是 2023 年中的某一天的日期，例如 20230902，20231223。yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
请你帮小蓝计算下按上述条件一共能找到多少个不同的 2023 年的日期。对于相同的日期你只需要统计一次即可。

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include <iostream>
#include<vector>using namespace std;typedef long long ll;
int main()
{vector<int> v({ 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 });int monthday[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };int count = 0;for (int month = 1; month <= 12; month++){for (int day = 1; day <= monthday[month]; day++){int k = 0;int a[] = { 2,0,2,3,month / 10,month % 10,day / 10,day % 10 };for (int i = 0; i < v.size(); i++){if (v[i] == a[k]){k++;if (k == 8){count++;break;}}}}}cout << count;return 0;
}

试题B：001的串的熵

#include <iostream>
using namespace std;int main() {double n = 23333333.0;for (long long i = 0; i <= n / 2; i++){double sum = 0.0;sum -= (i * i / n * log2(i / n)) + ((n - i) * ((n - i) / n) * log2((n - i) / n));if (sum > 11625907.5 && sum < 11625907.6) {cout << i << endl;break;}}return 0;
}

试题C：冶炼金属

题目描述

小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金

属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。

现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。

根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

输入格式

第一行一个整数 N，表示冶炼记录的数目。

接下来输入 N 行，每行两个整数 A、B，含义如题目所述。

输出格式

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

样例输入

样例输出

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 <iostream>
#include<vector>using namespace std;typedef long long ll;
int main()
{int n;cin >> n;vector<pair<int, int>> v;int max_sum = 9999999999;for (int i = 0; i < n; i++){int x, y;cin >> x >> y;v.push_back({ x,y });max_sum = min(x / y, max_sum);}int min_sum = 0;for (int i = max_sum - 1; i > 0; i--){int flag = 1;for (int j = 0; j < n; j++){if (v[j].first / i != v[j].second){flag = 0;break;}}if (flag == 0){min_sum = i + 1;break;}}cout << min_sum <<' '<< max_sum << endl;return 0;
}

试题D：飞机降落

N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早

可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。降落过程需要 Li个单位时间。

一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。

请你判断 N 架飞机是否可以全部安全降落。

输入格式

输入包含多组数据。

第一行包含一个整数 T，代表测试数据的组数。

对于每组数据，第一行包含一个整数 N。

以下 N 行，每行包含三个整数：Ti，Di 和 Li。

输出格式

对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。

样例输入

样例输出

YES
NO

#include <iostream>
#include<vector>using namespace std;struct node
{int t, d, l;
};bool dfs(int u, int last,vector<node>& v, vector<bool>& hash)
{if (u == v.size()) return true;for (int i = 0; i < v.size(); i++){if (v[i].t + v[i].d >= last && !hash[i]){hash[i] = true;if (dfs(u + 1, max(last, v[i].t) + v[i].l, v, hash)) return true;hash[i] = false;}}return false;
}int main()
{int T;cin >> T;while (T--){int n;cin >> n;vector<node> v(n);vector<bool> hash(n);for (int i = 0; i < n; i++){cin >> v[i].t >> v[i].d >> v[i].l;}if (dfs(0, 0, v, hash)) cout << "YES" << endl;else cout << "NO" << endl;}return 0;
}

在DFS函数中，last参数表示上一架飞机完成降落的时间。当递归调用dfs(u + 1, max(last, t) + l)时，这里的关键是确定当前飞机的最早可开始降落时间，并计算其结束时间以约束后续飞机的降落时间。具体逻辑如下：

时间窗口约束
当前飞机的开始时间必须同时满足两个条件：
- 不能早于其到达时间 t（即必须满足 t ≤ 开始时间）。
- 不能早于上一架飞机的结束时间 last（即必须满足 last ≤ 开始时间）。
  因此，实际开始时间为 max(t, last)。
结束时间计算
当前飞机降落需要 l 个单位时间，因此其结束时间为 max(t, last) + l。
这个结束时间将作为下一层递归的 last 参数，确保后续飞机的开始时间不会与此冲突。

示例说明
假设上一架飞机在 last=20 完成降落，当前飞机的 t=15（到达时间）且 d=5（允许最晚在 t+d=20 开始降落）。此时：

开始时间必须取 max(20, 15) = 20（受限于前一架飞机的结束时间）。
结束时间为 20 + l，该值成为后续飞机的 last 参数。

若当前飞机的 t=25，而 last=20：

开始时间取 max(20, 25) = 25（受限于自身到达时间）。
结束时间为 25 + l，作为后续约束。

试题E：接龙数列

题目描述

对于一个长度为 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

样例输出

#include <iostream>
#include<vector>using namespace std;int aaa(int x)
{while (x / 10){x /= 10;}return x;
}
int main()
{int n;cin >> n;vector<int> v(n);for (int i = 0; i < n; i++) cin >> v[i];vector<vector<int>> dp(n,vector<int>(10));dp[0][v[0] % 10] = 1;for (int i = 1; i < n; i++){int tail = v[i] % 10;for (int j = 0; j < 10; j++){dp[i][j] = dp[i - 1][j];}dp[i][tail] = max(dp[i - 1][aaa(v[i])] + 1, dp[i - 1][tail]);}int count = 0;for (int i = 0; i < 10; i++){count = max(count, dp[n - 1][i]);}cout << n - count;return 0;
}

通过计算最小删除数可能会比较麻烦，所以我们可以求出接龙数列的最大长度，反其道而行

这里的dp[i][j]表示的含义：在前i个数据中以j位置为结尾的最大长度

dp[i][tail]=max(dp[i-1][head]+1,dp[i-1][tail])：第一种就是选i位置的元素，第二种就是删除i位置的元素

试题F：岛屿个数

题目描述

小蓝得到了一副大小为 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’。

输出格式

对于每组数据，输出一行，包含一个整数表示答案。

样例输入

样例输出

1
3

#include <iostream>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>using namespace std;int dirss[8][2] = { {-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1} };
int dirs[4][2] = { {-1,0},{0,1},{1,0},{0,-1} };void dfs1(int x, int y, vector<vector<bool>>& hash, vector<vector<int>>& v)
{for (auto dir : dirss){int nx = x + dir[0], ny = y + dir[1];if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size() && !hash[nx][ny] && v[nx][ny] == 0){v[nx][ny] = 2;hash[nx][ny] = true;dfs1(nx, ny, hash, v);}}
}bool dfs(int x, int y, vector<vector<bool>>& hash, vector<vector<int>>& v)
{for (auto dir : dirs){int nx = x + dir[0], ny = y + dir[1];if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size() && !hash[nx][ny] && v[nx][ny] == 1){hash[nx][ny] = true;dfs(nx, ny, hash, v);}}for (auto dir : dirss){int nx = x + dir[0], ny = y + dir[1];if (nx >= 0 && nx < v.size() && ny >= 0 && ny < v[0].size()){if (v[nx][ny] == 2) return true;}}return false;
}
int main()
{int T;cin >> T;while (T--){int m, n;cin >> m >> n;vector<vector<int>> v(m+2, vector<int>(n+2, 0));for (int i = 1; i <= m; i++){string s1;cin >> s1;for (int j = 1; j <= n; j++){v[i][j] = s1[j - 1] - '0';}}int count = 0;vector<vector<bool>> hash(m + 2, vector<bool>(n + 2, false));hash[0][0] = true;v[0][0] = 2;dfs1(0, 0, hash, v);for (int i = 1; i <= m; i++){for (int j = 1; j <= n; j++){if (!hash[i][j] && v[i][j] == 1){if (dfs(i, j, hash, v)) count++;}}}cout << count << endl;}return 0;
}

这道题的难点在于如何排除子岛屿，我们可以加一圈外海（1），并且将所有与外海相连的海域统计为（2），之后在计算岛屿个数的时候只需要统计岛屿周围是否存在外海即可

试题G：子串简写

题目描述

程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internation-alization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简写成 K8s, Lanqiao 简写成 L5o 等。

在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。

给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头c2 结尾的子串可以采用这种简写？

输入格式

第一行包含一个整数 K。

第二行包含一个字符串 S 和两个字符 c1 和 c2。

输出格式

一个整数代表答案。

样例输入

4
abababdb a b

样例输出

#include <iostream>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>
#include<string>using namespace std;int main()
{int k;string s;cin >> k >> s;char a, b;cin >> a >> b;vector<int> v1;vector<int> v2;for (int i = 0; i < s.size(); i++){if (s[i] == a) v1.push_back(i);if (s[i] == b) v2.push_back(i);}long long count = 0;for (int i = 0; i < v1.size(); i++){auto it=lower_bound(v2.begin(), v2.end(), v1[i] + k-1);count += v2.end() - it;}cout << count << endl;return 0;
}

这道题用二分查找算法即可解决，count+=v2.end()-it是为了满足条件的元素数量累加到 count

试题H：整数删除

题目描述

给定一个长度为 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>
#include<vector>
#include <cmath>
#include <queue>
#include<algorithm>
#include <set>
#include<string>using namespace std;struct cmp {bool operator()(pair<long long, long long> a, pair<long long, long long> b) {if (a.first == b.first) return a.second > b.second; // 数值相同则索引小的优先return a.first > b.first; // 数值小的优先（构建小根堆）}
};
int main()
{int n, k;cin >> n >> k;vector<long long> v(n);priority_queue<pair<long long, long long>,vector<pair<long long, long long>>,cmp> q;for (int i = 0; i < n; i++){cin >> v[i];q.push({v[i],i});}while (k){long long a = q.top().first, b = q.top().second;q.pop();if (v[b] == a){v[b] = -1;int x = b - 1;while (x >= 0){if (v[x] == -1){x--;continue;}v[x] += a;q.push({ v[x],x});break;}int y = b + 1;while (y < n){if (v[y] == -1){y++;continue;}v[y] += a;q.push({ v[y],y });break;}k--;}else{continue;}}for (int i = 0; i < n; i++){if (v[i] != -1) cout << v[i] << ' ';}return 0;
}

这题主要考察如何创建小根堆，只要将被删除数改为-1，并将被删除数加到左右两边非负数的数据即可

试题I：景区导游

题目描述

某景区一共有 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 之后，花费在摆渡车上的时间。

样例输入

样例输出

10 7 13 14

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;const long long MAXN = 1e5 + 5;
const long long LOG = 20;vector<pair<long long, long long>> tree[MAXN];//存储树的邻接表。每个节点u对应一个向量，其中每个元素是一个pair，包含子节点v和边权w。表示节点u与节点v之间有一条边，权值为w。
long long depth[MAXN];//存储每个节点的深度。深度表示从根节点到该节点的路径长度。根节点的深度通常初始化为0或1。
long long fa[MAXN][LOG];//存储每个节点的2^i级祖先。fa[u][i]表示节点u的第2^i级祖先。通过预处理，可以在O(logN)时间内找到任意两个节点的最近公共祖先（LCA）。
long long dis[MAXN][LOG]; 存储每个节点到其2^ i级祖先的距离。dis[u][i]表示节点u到其第2^ i级祖先的路径总权值。用于快速计算两个节点之间的路径距离。void dfs(long long u, long long pre) {depth[u] = depth[pre] + 1;fa[u][0] = pre;for (long long i = 1; i < LOG; ++i) {fa[u][i] = fa[fa[u][i - 1]][i - 1];dis[u][i] = dis[u][i - 1] + dis[fa[u][i - 1]][i - 1];}for (auto& v : tree[u]) {long long a = v.first, b = v.second;if (a != pre) {dis[a][0] = b;dfs(a, u);}}
}long long lca(long long u, long long v, long long& dist) {dist = 0;if (depth[u] < depth[v]) swap(u, v);// 上提u到v的深度for (long long i = LOG - 1; i >= 0; --i) {if (depth[fa[u][i]] >= depth[v]) {dist += dis[u][i];u = fa[u][i];}}if (u == v) return u;// 同时上提找LCAfor (long long i = LOG - 1; i >= 0; --i) {if (fa[u][i] != fa[v][i]) {dist += dis[u][i] + dis[v][i];u = fa[u][i];v = fa[v][i];}}dist += dis[u][0] + dis[v][0];return fa[u][0];
}long long getDistance(long long u, long long v) {long long d;lca(u, v, d);return d;
}int main() {long long N, K;cin >> N >> K;for (long long i = 0; i < N - 1; ++i) {long long u, v, t;cin >> u >> v >> t;tree[u].emplace_back(v, t);tree[v].emplace_back(u, t);}// 初始化根节点为1memset(depth, 0, sizeof(depth));dfs(1, 0); // 1的父节点设为0vector<long long> A(K);for (long long i = 0; i < K; ++i) {cin >> A[i];}// 计算原始总时间long long original_total = 0;if (K > 1) {for (long long i = 0; i < K - 1; ++i) {original_total += getDistance(A[i], A[i + 1]);}}vector<long long> ans(K);for (long long i = 0; i < K; ++i) {if (K == 1) { // 特殊情况处理ans[i] = 0;}else if (i == 0) {ans[i] = original_total - getDistance(A[0], A[1]);}else if (i == K - 1) {ans[i] = original_total - getDistance(A[K - 2], A[K - 1]);}else {long long d1 = getDistance(A[i - 1], A[i]);long long d2 = getDistance(A[i], A[i + 1]);long long d3 = getDistance(A[i - 1], A[i + 1]);ans[i] = original_total - d1 - d2 + d3;}}for (long long i = 0; i < K; ++i) {cout << ans[i] << (i == K - 1 ? "\n" : " ");}return 0;
}

这道题就是一道lca的模板题，直接套模板即可