(｡･∀･)ﾉﾞ20 年的最后一天了耶！
本蒟蒻又来写题解了（
才不是没有找到题解才来写的呢，But 这次出了些意外没有 AK 😭是我不配（
过菜了！=== 21-02-25 update ===
感谢评论区老哥提供的测试点，经测试修改成功 AK!
感受到了自己 Debug 能力的不足，新年继续努力吧~🥳Tips：
全部采用 C++ 求解
代码部分 ——
纯享版不写注释，适合
品味；注释版有一定量的注释，适合理解；
let me try用于在看懂代码的前提下，自己顺着思路码一遍使用的提示版。
那么各位，咱们开始吧！
惨案
=== 21-02-25 update ===
试题集
链接
概况
7-1 祖传好运 (15分)
我们首先定义 0 到 9 都是好运数，然后从某个好运数开始，持续在其右边添加数字，形成新的数字。我们称一个大于 9 的数字 N 具有祖传好运，如果它是由某个好运数添加了一个个位数字得到的，并且它能被自己的位数整除。
例如 123 就是一个祖传好运数。首先因为 1 是一个好运数的老祖宗，添加了 2 以后，形成的 12 能被其位数 2 （即 12 是一个 2 位数）整除，所以 12 是一个祖传好运数；在 12 后面添加了 3 以后，形成的 123 能被其位数 3 整除，所以 123 是一个祖传好运数。
本题就请你判断一个给定的正整数 N 是不是具有祖传的好运。
输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出正整数 K (≤1000)；第 2 行给出 K 个不超过 \(10^{9}\) 的待评测的正整数，注意这些数字都保证没有多余的前导零。
输出格式：
对每个待评测的数字，在一行中输出 Yes 如果它是一个祖传好运数，如果不是则输出 No。
输入样例：
5
123 7 43 2333 56160
输出样例：
Yes
Yes
No
No
Yes
解析
题意再放送
给你一堆数，如果它从高位到低位、每增加一位时所得到的数字 都 能 整除 它本身的位数，则输出 Yes，反之 No。
思路
很明显了，就是模拟题，对于从高位向低位走的操作，使用 std::string会很舒服。
代码
纯享版
#include <cstdio>
#include <string>
using std::string;
bool judge(int num) {
string s = std::to_string(num);
num = 0;
for (int i = 0; i < s.length(); i++) {
num *= 10;
num += s[i] - '0';
if (num % (i + 1) != 0) {
return false;
}
}
return true;
}
int main() {
int n, num;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num);
puts(judge(num) ? "Yes" : "No");
}
return 0;
}
注释版
#include <cstdio>
#include <string>
// 就不用 namespace std，略略略
using std::string;
/**
* 判断数字是否为好运数的函数
* @param num 那个数
* @return 是或不是好运数
*/
bool judge(int num) {
// int 转 string
string s = std::to_string(num);
num = 0;
// 从高位往低位遍历
for (int i = 0; i < s.length(); i++) {
// 按位累加
num *= 10;
num += s[i] - '0';
// i + 1 即为当前数字的位数
if (num % (i + 1) != 0) {
return false;
}
}
return true;
}
int main() {
int n, num;
// IO IO IO
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num);
puts(judge(num) ? "Yes" : "No");
}
return 0;
}
let me try
#include <cstdio>
#include <string>
using std::string;
/**
* 判断数字是否为好运数的函数
* @param num 那个数
* @return 是或不是好运数
*/
bool judge(int num) {
// int 转 string
// 从高位往低位遍历
// 字符下标即为当前数字的位数
}
int main() {
// 输入、判断、输出
return 0;
}
7-2 找奇葩 (20分)
在一个长度为 n 的正整数序列中，所有的奇数都出现了偶数次，只有一个奇葩奇数出现了奇数次。你的任务就是找出这个奇葩。
输入格式：
输入首先在第一行给出一个正整数 n（≤ \(10^{4}\)），随后一行给出 n 个满足题面描述的正整数。每个数值不超过 \(10^{5}\)，数字间以空格分隔。
输出格式：
在一行中输出那个奇葩数。题目保证这个奇葩是存在的。
输入样例：
12
23 16 87 233 87 16 87 233 23 87 233 16
输出样例：
233
解析
题意再放送
给你一堆数，奇数偶数都有，但是只有一个奇数很奇葩，只出现奇数次。换言之，其他奇数都出现了偶数次，请你找出那个奇葩。
思路
只需要去处理和统计奇数就行，偶数无视掉。
- 使用 map 全部存起来，再遍历一次得到答案
- 使用异或位运算，把奇数全部异或，最终的值即为答案
map 是常规思路，而异或这个方法，没有接触过几乎很难想到，其实这道题就是 “落单的数” 这道经典题的小修改版。
异或，相同为 0 不同为 1 ，过程：
[1, 1, 2] -> 0 ^ 1 = 1 -> 1 ^ 1 = 0 -> 00 ^ 10 -> 10 -> 2
代码
纯享版
#include <cstdio>
int main() {
int n, num;
scanf("%d", &n);
int res = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num);
if (num & 1) {
res ^= num;
}
}
printf("%d\n", res);
return 0;
}
注释版
#include <cstdio>
int main() {
int n, num;
scanf("%d", &n);
// 使用 0 作为初始值进行所有奇数的异或运算
int res = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num);
// 如果 num 为奇数，则进行异或，num & 1 等价于 num % 2 == 1
if (num & 1) {
res ^= num;
}
}
// 输出
printf("%d\n", res);
return 0;
}
let me try
#include <cstdio>
int main() {
// 使用 0 作为初始值
// 输入
// 进行所有奇数的异或运算
// 输出
return 0;
}
7-3 舍入 (20分)
不同的编译器对浮点数的精度有不同的处理方法。常见的一种是“四舍五入”，即考察指定有效位的后一位数字，如果不小于 5，就令有效位最后一位进位，然后舍去后面的尾数；如果小于 5 就直接舍去尾数。另一种叫“截断”，即不管有效位后面是什么数字，一概直接舍去。还有一种是“四舍六入五成双”，即当有效位的后一位数字是 5 时，有 3 种情况要考虑：如果 5 后面还有其它非 0 尾数，则进位；如果没有，则当有效位最后一位是单数时进位，双数时舍去，即保持最后一位是双数。
本题就请你写程序按照要求处理给定浮点数的舍入问题。
输入格式：
输入第一行给出两个不超过 100 的正整数 N 和 D，分别是待处理数字的个数和要求保留的小数点后的有效位数。随后 N 行，每行给出一个待处理数字的信息，格式如下：
指令符 数字
其中指令符是表示舍入方法的一位数字，1 表示“四舍五入”，2 表示“截断”，3 表示“四舍六入五成双”；数字是一个总长度不超过 200 位的浮点数，且不以小数点开头或结尾，即 0.123 不会写成 .123，123 也不会写成 123.。此外，输入保证没有不必要的正负号（例如 -0.0 或 +1）。
输出格式：
对每个待处理数字，在一行中输出根据指令符处理后的结果数字。
输入样例：
7 3
1 3.1415926
2 3.1415926
3 3.1415926
3 3.14150
3 3.14250
3 3.14251
1 3.14
输出样例：
3.142
3.141
3.142
3.142
3.142
3.143
3.140
解析
题意再放送
给你一堆数字，你要根据指令的要求对其进行精度舍入。
- 四舍五入
- 直接舍弃
- 如果有效位的后一位是5
- 5 后面还有非 0 尾数，进位
- 若没有尾数，则有效位最后一位是奇数时进位，偶数时舍弃
思路
一个比较纠缠的模拟题，u1s1，和天梯赛的口罩题有的一拼，只能说能提升思维的全面性吧，算法提升约等于 0
反正我是🤮了，考虑前：
坑点：
- 负号处理
- 9.9999999 类似这种牵一发而动全身的数字
- 给你整数，需要补 0 成为浮点数
- ？？？暂未发现（以下为做出的尝试，均不是卡点
- 正号处理，去掉或保留
- 前导 0 的处理
处理后：
看到返回结果时就很：
提交了几次后还不能过时：
是我不配了😤
=== 21-02-25 update ===
感谢评论区老哥@昵称很长很长真是太好了提供的测试点，经测试修改成功 AC!（舒服了😋）
代码
求大佬教我怎么改 QAQ (✅已 AC ）
#include <cstdio>
#include <string>
#include <algorithm>
using std::string;
/**
* 操作 2，舍弃有效位后面位数的操作
* @param num 原数字
* @param ans 处理值
* @param dot 小数点位置
* @param bit 保留位数
*/
void cmd2(string& num, string& ans, int dot, int bit) {
ans = num.substr(0, dot + bit + 1);
}
/**
* 操作 1，四舍五入
* @param num 原数字
* @param ans 处理值
* @param dot 小数点位置
* @param bit 保留位数
*/
void cmd1(string& num, string& ans, int dot, int bit) {
// 五入
if (num[dot + bit + 1] >= '5') {
int index = dot + bit, carry = 0;
// 模拟进位操作，可处理 9.99999 这种数字
while ((num[index] != '-' && num[index] != '+') && index >= 0) {
if (num[index] == '.') {
ans.push_back('.');
} else {
carry += num[index] - '0' + (index == dot + bit ? 1 : 0);
ans.push_back(carry % 10 + '0');
carry /= 10;
}
index--;
}
// 如果 carry 还有值，则再补上 1
if (carry) {
ans.push_back('1');
}
// 补负号
if (num[0] == '-') {
ans.push_back('-');
}
// 翻转得到答案
std::reverse(ans.begin(), ans.end());
} else {
// 四舍
cmd2(num, ans, dot, bit);
}
}
/**
* 类似于工厂模式，对指令做相应处理
* @param num 原数字
* @param cmd 指令
* @param bit 保留位数
* @return 答案
*/
string process(string& num, int cmd, int bit) {
// 找到点的位置
int dot = num.find('.');
int len = num.length();
string ans;
// 位数不够补 0，使得小数点后的位数至少为 bit + 1
// eg: bit = 3, num = "3.1" -> "3.1000"
if (len - dot - 1 < bit + 1) {
num.append(bit + 1 - len + dot + 1, '0');
}
// 进行对应处理
if (cmd == 1) {
cmd1(num, ans, dot, bit);
} else if (cmd == 2) {
cmd2(num, ans, dot, bit);
} else {
// 有效位的后一位进行四舍六入
if (num[dot + bit + 1] < '5') {
cmd2(num, ans, dot, bit);
} else if (num[dot + bit + 1] > '5') {
cmd1(num, ans, dot, bit);
} else {
// 有效位的后一位是 5 时
bool flag = false;
for (int i = dot + bit + 2; i < len; i++) {
if (num[i] != '0') {
flag = true;
break;
}
}
// 5 后面还有非 0 数字
if (flag) {
cmd1(num, ans, dot, bit);
} else {
// 有效位的最后一位是偶数时舍去后面的数，否则进位
if ((num[dot + bit] - '0') % 2 == 0) {
cmd2(num, ans, dot, bit);
} else {
cmd1(num, ans, dot, bit);
}
}
}
}
// ===== bug-fixed on 21-2-25 00:10 contributed by @昵称很长很长真是太好了 //
// 负数舍位后为 -0.0 时应去掉负号
// 当且仅当整数部分为 0 时
if (ans[0] == '-' && ans[1] == '0') {
bool flag = true;
for (int i = dot + 1; i < ans.length(); i++) {
if (ans[i] > '0') {
flag = false;
break;
}
}
if (flag) {
ans.erase(ans.begin());
}
}
// ===== bug-fixed on 21-2-25 00:10 contributed by @昵称很长很长真是太好了 //
return ans;
}
int main() {
int n, bit, cmd;
scanf("%d %d", &n, &bit);
char num[205];
for (int i = 0; i < n; i++) {
scanf("%d %s", &cmd, num);
string str{ num };
// 输入是整数时，补上小数点再处理
if (str.find('.') == string::npos) {
str.push_back('.');
}
puts(process(str, cmd, bit).c_str());
}
return 0;
}
7-4 最近的斐波那契数 (20分)
斐波那契数列 \(F_{n}\) 的定义为：对 n ≥ 0 有 \(F_{n+2}\)=\(F_{n+1}\)+\(F_{n}\)，初始值为 \(F_{0}\) = 0 和 \(F_{1}\) = 1。所谓与给定的整数 N 最近的斐波那契数是指与 N 的差之绝对值最小的斐波那契数。
本题就请你为任意给定的整数 N 找出与之最近的斐波那契数。
输入格式：
输入在一行中给出一个正整数 N（≤\(10^{8}\)）。
输出格式：
在一行输出与 N 最近的斐波那契数。如果解不唯一，输出最小的那个数。
输入样例：
305
输出样例：
233
样例解释
部分斐波那契数列为 { 0, 1, 1, 2, 3, 5, 8, 12, 21, 34, 55, 89, 144, 233, 377, 610, ... }。可见 233 和 377 到 305 的距离都是最小值 72，则应输出较小的那个解。
解析
题意再放送
给你一个数，找出斐波那契数列里和它最接近的数
思路
我佛了，这道题 2 分钟秒了，上一道模拟我做了 2 个小时🙃🙃🙃
继续模拟，按照动态规划的思想，通过保存上一个 fib 数和现在这个 fib 数，最后与所给的数字进行作差比较即可
代码
纯享版
#include <cstdio>
int main() {
int fst = 0, sec = 1, fib = 1;
int n, former = fst;
scanf("%d", &n);
while (fib < n) {
former = fib;
fst = sec;
sec = fib;
fib = fst + sec;
}
printf("%d\n", fib - n >= n - former ? former : fib);
return 0;
}
注释版
#include <cstdio>
int main() {
// 初始化数列的前三个数
int fst = 0, sec = 1, fib = 1;
int n, former = fst;
scanf("%d", &n);
// 找到数列第一个比 n 大的数
while (fib < n) {
former = fib;
fst = sec;
sec = fib;
fib = fst + sec;
}
// [former, n, fib] -> 看谁离 n 最近（差值的绝对值最小，相同时优先选择former）
printf("%d\n", fib - n >= n - former ? former : fib);
return 0;
}
let me try
#include <cstdio>
int main() {
// 初始化数列的前三个数
// 输入
// 找到数列第一个比 n 大的数
// [former, n, fib] -> 看谁离 n 最近（差值的绝对值最小，相同时优先选择former）
return 0;
}
7-5 子串与子列 (25分)
子串是一个字符串中连续的一部分，而子列是字符串中保持字符顺序的一个子集，可以连续也可以不连续。例如给定字符串 atpaaabpabtt，pabt是一个子串，而 pat 就是一个子列。
现给定一个字符串 S 和一个子列 P，本题就请你找到 S 中包含 P 的最短子串。若解不唯一，则输出起点最靠左边的解。
输入格式：
输入在第一行中给出字符串 S，第二行给出 P。S 非空，由不超过 \(10^{4}\) 个小写英文字母组成；P 保证是 S 的一个非空子列。
输出格式：
在一行中输出 S 中包含 P 的最短子串。若解不唯一，则输出起点最靠左边的解。
输入样例：
atpaaabpabttpcat
pat
输出样例：
pabt
解析
题意再放送
给你两个字符串，S 和 P。要你找出顺序包含 P 的 S 的最短子串
思路
第一次做这道题的时候，使用了一次贪心的思想，即：
- 类似 KMP 算法一样，逐个进行匹配
- 从找到 P 的首字母开始，使用 vector 记录每个首字母的下标位置
- 直到按顺序找到第一个包含 P 的子串（样例搜索到符合条件的第一个子串：paaabpabt）
- 开始检查，找到这个子串里最短的符合要求的子串
结果测试点二答案错误：
自己再调试了一波，发现了一次贪心匹配是会漏掉一些情况的：
abababababababababaab
baab
答案应该为 baab，程序执行结果却是 babab，这是由于贪心过程中无法中断，导致漏掉一些更短的答案
接着我尝试了两次贪心，即从前往后和从后往前两次，代码几乎是重复的。成功 AC 时，我开始怀疑贪心是不是正解😂
两次贪心：
最后本着试试的心态，开始暴力，果然 300ms 的时限成功卡死测试点 2，于是自己进行了优化和剪枝，也成功 AC 了。
暴力：
暴力（优化）：
代码
纯享版
暴力（暴力出奇迹）
#include <cstdio>
#include <vector>
#include <string>
using std::string;
using std::vector;
constexpr int MAX_N = 10050;
char str1[MAX_N], str2[MAX_N];
void solve(string& s1, string& s2, string& ans) {
vector<int> st, ed;
int len1 = s1.length(), len2 = s2.length();
for (int i = 0; i < len1; i++) {
if (s1[i] == s2.front()) {
st.push_back(i);
}
if (s1[i] == s2.back()) {
ed.push_back(i);
}
}
for (int i = 0, j = 0; i < st.size() && j < ed.size(); i++) {
while (st[i] + len2 - 1 > ed[j]) {
j++;
}
for (int k = j; k < ed.size(); k++) {
if (!ans.empty() && ed[k] - st[i] + 1 >= ans.length()) {
break;
}
for (int a = st[i], b = 0; a <= ed[k]; a++) {
if (s1[a] == s2[b]) {
b++;
if (b == len2) {
string temp = s1.substr(st[i], ed[k] - st[i] + 1);
if (ans.empty() || ans.length() > temp.length()) {
ans = temp;
}
if (ans.length() == len2) {
return;
}
}
}
}
}
}
}
int main() {
scanf("%s %s", str1, str2);
vector<int> idx;
string s1{ str1 }, s2{ str2 }, ans;
solve(s1, s2, ans);
puts(ans.c_str());
return 0;
}
贪心
#include <cstdio>
#include <vector>
#include <string>
using std::string;
using std::vector;
constexpr int MAX_N = 10050;
char str1[MAX_N], str2[MAX_N];
void findBest(vector<int>& v, string& s1, string& s2, string& ans, int end) {
int len = s2.length();
while (!v.empty()) {
int index = v.back();
v.pop_back();
if (index + len - 1 <= end) {
int j = 0;
for (int i = index; i <= end; i++) {
if (s1[i] == s2[j]) {
j++;
}
}
if (j == len) {
string temp = s1.substr(index, end - index + 1);
if (ans.empty() || temp.length() < ans.length()) {
ans = temp;
return;
}
}
}
}
}
void findBestRev(vector<int>& v, string& s1, string& s2, string& ans, int st) {
int len = s2.length();
while (!v.empty()) {
int end = v.back();
v.pop_back();
if (st + len - 1 <= end) {
int j = 0;
for (int i = st; i <= end; i++) {
if (s1[i] == s2[j]) {
j++;
}
}
if (j == len) {
string temp = s1.substr(st, end - st + 1);
if (ans.empty() || temp.length() < ans.length()) {
ans = temp;
return;
}
}
}
}
}
int main() {
scanf("%s %s", str1, str2);
vector<int> idx;
string s1{ str1 }, s2{ str2 }, ans;
int len1 = s1.length();
int len2 = s2.length();
for (int i = 0, j = 0; i < len1; i++) {
if (str1[i] == str2[0]) {
idx.push_back(i);
}
if (str1[i] == str2[j]) {
j++;
if (j == len2) {
findBest(idx, s1, s2, ans, i);
idx.clear();
j = 0;
}
}
}
for (int i = len1 - 1, j = len2 - 1; i >= 0; i--) {
if (str1[i] == str2[len2 - 1]) {
idx.push_back(i);
}
if (str1[i] == str2[j]) {
j--;
if (j == -1) {
findBestRev(idx, s1, s2, ans, i);
idx.clear();
j = len2 - 1;
}
}
}
puts(ans.c_str());
return 0;
}
注释版
暴力
#include <cstdio>
#include <vector>
#include <string>
using std::string;
using std::vector;
constexpr int MAX_N = 10050;
char str1[MAX_N], str2[MAX_N];
/**
* 暴力匹配函数
* 通过预处理得到 P 的首尾字符在 S 中的所有下标位置
* 通过首位置与尾位置的相对位置筛选出最合适的位置进行查找
* 找到或找不到都进行一定的剪枝
* @param s1 主串 S
* @param s2 “客”串 P
* @param ans 最短子串
*/
void solve(string& s1, string& s2, string& ans) {
vector<int> st, ed;
int len1 = s1.length(), len2 = s2.length();
// 获得 s2 的首尾字符在 s1 中的所有位置
for (int i = 0; i < len1; i++) {
if (s1[i] == s2.front()) {
st.push_back(i);
}
if (s1[i] == s2.back()) {
ed.push_back(i);
}
}
// 暴力匹配
for (int i = 0, j = 0; i < st.size() && j < ed.size(); i++) {
// 找到第一个合适的尾位置，即首尾位置确定的子串长度一定是要 >= s2 的长度的
while (st[i] + len2 - 1 > ed[j]) {
j++;
}
// 检查是否为合法子串
for (int k = j; k < ed.size(); k++) {
// 已有预选答案且当前子串的长度比答案字符串长，剪枝
if (!ans.empty() && ed[k] - st[i] + 1 >= ans.length()) {
break;
}
// 开始匹配，看子串是否顺序包含 s2
for (int a = st[i], b = 0; a <= ed[k]; a++) {
if (s1[a] == s2[b]) {
b++;
// 匹配成功
if (b == len2) {
string temp = s1.substr(st[i], ed[k] - st[i] + 1);
// 没有答案或答案更优时更新
if (ans.empty() || ans.length() > temp.length()) {
ans = temp;
}
// 找到的答案 == s2，即最优解，直接 return
if (ans.length() == len2) {
return;
}
}
}
}
}
}
}
int main() {
scanf("%s %s", str1, str2);
vector<int> idx;
string s1{ str1 }, s2{ str2 }, ans;
solve(s1, s2, ans);
puts(ans.c_str());
return 0;
}
贪心
#include <cstdio>
#include <vector>
#include <string>
using std::string;
using std::vector;
constexpr int MAX_N = 10050;
char str1[MAX_N], str2[MAX_N];
/**
* 正向贪心，举例：atpaaabpabttpcat pat -> paaabpabt -> 有两个 p
* 优先从最靠近 t 的 p 开始匹配，得到答案子串：pabt
* 即每次选择距离尾字符最近的首字符，第一次匹配得到的答案一定是当前子串中最优的
* @param v 首字符位置数组
* @param s1 主串
* @param s2 “客”串
* @param ans 答案子串
* @param end 尾字符位置
*/
void findBest(vector<int>& v, string& s1, string& s2, string& ans, int end) {
int len = s2.length();
// 从后往前依次寻找
while (!v.empty()) {
// 模拟栈的存取
int index = v.back();
v.pop_back();
// 如果长度合理，则进行查找匹配
if (index + len - 1 <= end) {
int j = 0;
for (int i = index; i <= end; i++) {
if (s1[i] == s2[j]) {
j++;
}
}
// 满足要求，检验答案是否更优
if (j == len) {
string temp = s1.substr(index, end - index + 1);
if (ans.empty() || temp.length() < ans.length()) {
ans = temp;
// 第一个即为当前最优，因此直接 return
return;
}
}
}
}
}
/**
* 反向贪心，举例：atpaaabpabttpcat pat -> pcat
* @param v 尾字符位置数组
* @param s1 主串
* @param s2 “客”串
* @param ans 答案子串
* @param st 首字符位置
*/
void findBestRev(vector<int>& v, string& s1, string& s2, string& ans, int st) {
int len = s2.length();
// 几乎和上一个函数一致，只修改了首尾字符的变量使用位置而已
while (!v.empty()) {
int end = v.back();
v.pop_back();
if (st + len - 1 <= end) {
int j = 0;
for (int i = st; i <= end; i++) {
if (s1[i] == s2[j]) {
j++;
}
}
if (j == len) {
string temp = s1.substr(st, end - st + 1);
if (ans.empty() || temp.length() < ans.length()) {
ans = temp;
return;
}
}
}
}
}
int main() {
scanf("%s %s", str1, str2);
vector<int> idx;
string s1{ str1 }, s2{ str2 }, ans;
int len1 = s1.length();
int len2 = s2.length();
// 无聊的正向匹配
for (int i = 0, j = 0; i < len1; i++) {
if (str1[i] == str2[0]) {
idx.push_back(i);
}
if (str1[i] == str2[j]) {
j++;
if (j == len2) {
findBest(idx, s1, s2, ans, i);
idx.clear();
j = 0;
}
}
}
// 无聊的反向匹配
for (int i = len1 - 1, j = len2 - 1; i >= 0; i--) {
if (str1[i] == str2[len2 - 1]) {
idx.push_back(i);
}
if (str1[i] == str2[j]) {
j--;
if (j == -1) {
findBestRev(idx, s1, s2, ans, i);
idx.clear();
j = len2 - 1;
}
}
}
puts(ans.c_str());
return 0;
}
let me try
贪心思路仅供参考，这里放暴力的吧
#include <cstdio>
#include <vector>
#include <string>
using std::string;
using std::vector;
constexpr int MAX_N = 10050;
char str1[MAX_N], str2[MAX_N];
/**
* 暴力匹配函数
* 通过预处理得到 P 的首尾字符在 S 中的所有下标位置
* 通过首位置与尾位置的相对位置筛选出最合适的位置进行查找
* 找到或找不到都进行一定的剪枝
* @param s1 主串 S
* @param s2 “客”串 P
* @param ans 最短子串
*/
void solve(string& s1, string& s2, string& ans) {
// 获得 s2 的首尾字符在 s1 中的所有位置
// 暴力匹配
// 找到第一个合适的尾位置，即首尾位置确定的子串长度一定是要 >= s2 的长度的
// 检查是否为合法子串
// 已有预选答案且当前子串的长度比答案字符串长，剪枝
// 开始匹配，看子串是否顺序包含 s2
// 匹配成功
// 没有答案或答案更优时更新
// 找到的答案 == s2，即最优解，直接 return
}
int main() {
scanf("%s %s", str1, str2);
vector<int> idx;
string s1{ str1 }, s2{ str2 }, ans;
// 调用函数
puts(ans.c_str());
return 0;
}
End
就题目难度而言，T3 才值 25 分吧！T4 比 T1 简单，如果知道异或和map，那么 T2 也很简单。。。
难度排序：T4 < T2 < T1 < T5 << T3
再也不说乙级简单了。。。😭😭😭
题解仅供参考，若大家有思路更清晰，代码量更少的解法，欢迎留言哦~~
大家友善讨论，共同进步呀！