专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
一、题目描述
给定字符串A、B和正整数V，A的长度与B的长度相等，请计算A中满足如下条件的最大连续子串的长度：
该连续子串在A和B中的位置和长度均相同。
该连续子串|A[i] - B[i]|之和小于等于V。其中|A[i] - B[i]|表示两个字符ASCII码之差的绝对值。
二、输入描述
输入为三行：
第一行为字符串A，仅包含小写字母，1 <= A.length <= 1000。
第二行为字符串B，仅包含小写字母，1 <= B.length <= 1000。
第三行为正整数V，0 <= V <= 10000。
三、输出描述
字符串最大连续子串的长度，要求该子串|A[i] - B[i]|之和小于等于V。
四、测试用例
测试用例1
1、输入
abc
abd
1
2、输出
3
3、说明
字符串A为 “abc”，字符串B为 “abd”，V为1。
子串 “a” (A[0]) vs “a” (B[0]): |‘a’-‘a’| = 0。Sum = 0 <= 1。长度 = 1。maxLength = 1。
子串 “ab” (A[0…1]) vs “ab” (B[0…1]): |‘a’-‘a’| + |‘b’-‘b’| = 0+0 = 0。Sum = 0 <= 1。长度 = 2。maxLength = 2。
子串 “abc” (A[0…2]) vs “abd” (B[0…2]): |‘a’-‘a’| + |‘b’-‘b’| + |‘c’-‘d’| = 0+0+1 = 1。Sum = 1 <= 1。长度 = 3。maxLength = 3。 其他子串如 “b”, “bc”, “c” 等长度均不超过3。因此最大长度为3。
测试用例2
1、输入
xyz
abc
5
2、输出
0
3、说明
字符串A为 “xyz”，字符串B为 “abc”，V为5。
A[0]=‘x’, B[0]=‘a’: |‘x’-‘a’| = |120-97| = 23。
A[1]=‘y’, B[1]=‘b’: |‘y’-‘b’| = |121-98| = 23。
A[2]=‘z’, B[2]=‘c’: |‘z’-‘c’| = |122-99| = 23。 任何长度为1的子串，其ASCII差值之和都至少为23，远大于V=5。因此不存在满足条件的子串，最大长度为0。
五、解题思路
1、解题思路
题目要求找到两个等长字符串A和B中，位置和长度均相同，且对应字符ASCII码差值绝对值之和小于等于V的最大连续子串的长度。 核心思路是枚举所有可能的连续子串。一个连续子串可以由其起始位置 i 和结束位置 j 定义。
2、具体步骤：
- 双重循环遍历子串：
- 外层循环使用变量 i 从 0 到 n-1，代表子串的起始位置。
- 内层循环使用变量 j 从 i 到 n-1，代表子串的结束位置。这样 (i, j) 就定义了一个A和B中位置和长度均相同的连续子串。
- 计算差值和：
- 对于每个由 (i, j) 定义的子串，我们需要计算 sum(|A[k] - B[k]|) 其中 k 从 i 到 j。
- 在内层循环中，当 j 扩展时，currentSum 会累加 Math.abs(a.charAt(j) - b.charAt(j))。
- 条件判断与更新：
- 如果 currentSum <= v，说明当前子串 A[i…j] (以及对应的 B[i…j]) 满足条件。计算其长度为 j - i + 1，并与 maxLength 比较，取较大者更新 maxLength。
- 优化：如果 currentSum > v，由于所有字符ASCII码差值的绝对值都是非负的，那么以 i 为起点，继续向后扩展子串 (即增加 j)，其 currentSum 只会更大或不变，不可能再小于等于 v。因此，此时可以 break 内层循环，转而尝试下一个起始位置 i。这避免了不必要的计算。
六、Python算法源码
# coding: utf-8
def solve():
# 读取第一行输入：字符串A
a_str = input()
# 读取第二行输入：字符串B
b_str = input()
# 读取第三行输入：正整数V
v_val = int(input())
n = len(a_str) # 获取字符串的长度，A和B长度相等
max_length = 0 # 初始化最大连续子串的长度为0
# 外层循环：遍历所有可能的子串起始位置 i
# i 从 0 到 n-1
for i in range(n):
current_sum = 0 # 初始化当前子串的ASCII码差值之和
# 内层循环：遍历所有可能的子串结束位置 j
# j 从 i 到 n-1，确保子串的连续性
for j in range(i, n):
# 累加当前位置 (j) 对应字符在A和B中ASCII码差值的绝对值
# ord() 函数获取字符的ASCII值
current_sum += abs(ord(a_str[j]) - ord(b_str[j]))
# 判断当前子串的差值之和是否小于等于V
if current_sum <= v_val:
# 如果满足条件，计算当前子串的长度 (j - i + 1)
# 并更新max_length为当前长度和之前max_length中较大的一个
max_length = max(max_length, j - i + 1)
else:
# 如果current_sum已经大于V，那么以i为起点的更长子串的current_sum也必然大于V
# 因此，可以提前终止内层循环
break
# 输出计算得到的最大连续子串的长度
print(max_length)
if __name__ == "__main__":
# 调用解决函数
solve()
七、JavaScript算法源码
// 为了在Node.js等环境中直接运行并从控制台读取输入，
// 通常需要如下设置 (或者使用已经封装好的readline模块)。
// 以下代码核心逻辑部分是一个函数 `runSolution`，
// 假设输入已经通过某种方式获取并传递给它。
// 实际提交时，可能需要根据平台的输入输出规范调整。
function solveMain(inputA, inputB, inputV) {
// inputA: 字符串A
// inputB: 字符串B
// inputV: 整数V
const aStr = inputA; // 字符串A
const bStr = inputB; // 字符串B
const vVal = parseInt(inputV); // 正整数V，确保是数字类型
const n = aStr.length; // 获取字符串的长度，A和B长度相等
let maxLength = 0; // 初始化最大连续子串的长度为0
// 外层循环：遍历所有可能的子串起始位置 i
// i 从 0 到 n-1
for (let i = 0; i < n; i++) {
let currentSum = 0; // 初始化当前子串的ASCII码差值之和
// 内层循环：遍历所有可能的子串结束位置 j
// j 从 i 到 n-1，确保子串的连续性
for (let j = i; j < n; j++) {
// 累加当前位置 (j) 对应字符在A和B中ASCII码差值的绝对值
// charCodeAt() 方法获取字符的UTF-16码点 (对于ASCII字符等同于ASCII值)
currentSum += Math.abs(aStr.charCodeAt(j) - bStr.charCodeAt(j));
// 判断当前子串的差值之和是否小于等于V
if (currentSum <= vVal) {
// 如果满足条件，计算当前子串的长度 (j - i + 1)
// 并更新maxLength为当前长度和之前maxLength中较大的一个
maxLength = Math.max(maxLength, j - i + 1);
} else {
// 如果currentSum已经大于V，那么以i为起点的更长子串的currentSum也必然大于V
// 因此，可以提前终止内层循环
break;
}
}
}
// 输出计算得到的最大连续子串的长度
console.log(maxLength);
// return maxLength; // 如果需要在函数外部使用结果，可以返回
}
// Node.js 环境下的标准输入处理示例:
/*
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
terminal: false
});
let lines = [];
rl.on('line', (line) => {
lines.push(line);
if (lines.length === 3) { // 期望三行输入
solveMain(lines[0], lines[1], lines[2]);
rl.close();
}
});
*/
// 为了满足题目“控制台输入输出时，不要有其他文字描述，只有测试用例即可”，
// 在实际使用时，可以直接将 solveMain 的内容放在可执行脚本的顶层，
// 并使用适合该JS环境的 stdin 读取方式。
// 例如，对于一个简单的Node.js脚本，可以这样：
/*
const fs = require('fs');
const inputLines = fs.readFileSync(0, 'utf-8').trim().split('\n');
const A = inputLines[0];
const B = inputLines[1];
const V = parseInt(inputLines[2]);
solveMain(A, B, V);
*/
// 在这里，我将提供 `solveMain` 函数的主体，并假设输入已处理。
// 如果要直接粘贴运行，需要配合上述的 Node.js 输入处理代码。
八、C算法源码
#include <stdio.h> // 引入标准输入输出库，用于printf, scanf, fgets
#include <string.h> // 引入字符串处理库，用于strlen, strcspn
#include <stdlib.h> // 引入标准库，用于abs函数
#include <math.h> // 引入数学库 (abs 也在这里，但stdlib.h的int版本通常足够)
// 定义一个辅助函数来找到两个整数中的较大值
// C语言没有内置的max函数用于整数
int find_max(int a, int b) {
return (a > b) ? a : b;
}
int main() {
char a_str[1001]; // 存储字符串A，长度上限1000，加1为'\0'
char b_str[1001]; // 存储字符串B
int v_val; // 存储正整数V
// 读取字符串A (使用fgets防止缓冲区溢出，它会读取换行符)
fgets(a_str, sizeof(a_str), stdin);
// 移除fgets可能读取到的末尾换行符
a_str[strcspn(a_str, "\n")] = 0;
// 读取字符串B
fgets(b_str, sizeof(b_str), stdin);
// 移除fgets可能读取到的末尾换行符
b_str[strcspn(b_str, "\n")] = 0;
// 读取整数V
scanf("%d", &v_val);
int n = strlen(a_str); // 获取字符串的长度，A和B长度相等
int max_length = 0; // 初始化最大连续子串的长度为0
// 外层循环：遍历所有可能的子串起始位置 i
// i 从 0 到 n-1
for (int i = 0; i < n; i++) {
int current_sum = 0; // 初始化当前子串的ASCII码差值之和
// 内层循环：遍历所有可能的子串结束位置 j
// j 从 i 到 n-1，确保子串的连续性
for (int j = i; j < n; j++) {
// 累加当前位置 (j) 对应字符在A和B中ASCII码差值的绝对值
// char类型可以直接进行算术运算，其ASCII值会被使用
current_sum += abs(a_str[j] - b_str[j]); // abs() 来自 stdlib.h
// 判断当前子串的差值之和是否小于等于V
if (current_sum <= v_val) {
// 如果满足条件，计算当前子串的长度 (j - i + 1)
// 并更新max_length为当前长度和之前max_length中较大的一个
max_length = find_max(max_length, j - i + 1);
} else {
// 如果current_sum已经大于V，那么以i为起点的更长子串的current_sum也必然大于V
// 因此，可以提前终止内层循环
break;
}
}
}
// 输出计算得到的最大连续子串的长度，并换行
printf("%d\n", max_length);
return 0; // 表示程序正常结束
}
九、C++算法源码
#include <iostream> // 引入输入输出流库，用于 std::cin, std::cout
#include <string> // 引入字符串库，用于 std::string
#include <vector> // 引入向量库 (虽然此题没直接用，但常用)
#include <cmath> // 引入数学函数库，用于 std::abs
#include <algorithm>// 引入算法库，用于 std::max
int main() {
// 优化C++的cin/cout性能，使其不与C的标准I/O同步
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL); // 解除cin和cout的绑定
std::string a_str; // 用于存储字符串A
std::string b_str; // 用于存储字符串B
int v_val; // 用于存储正整数V
// 读取第一行输入：字符串A
std::cin >> a_str;
// 读取第二行输入：字符串B
std::cin >> b_str;
// 读取第三行输入：正整数V
std::cin >> v_val;
int n = a_str.length(); // 获取字符串的长度，A和B长度相等
int max_length = 0; // 初始化最大连续子串的长度为0
// 外层循环：遍历所有可能的子串起始位置 i
// i 从 0 到 n-1
for (int i = 0; i < n; ++i) { // 使用 ++i 是C++中一种常见的风格
int current_sum = 0; // 初始化当前子串的ASCII码差值之和
// 内层循环：遍历所有可能的子串结束位置 j
// j 从 i 到 n-1，确保子串的连续性
for (int j = i; j < n; ++j) {
// 累加当前位置 (j) 对应字符在A和B中ASCII码差值的绝对值
// a_str[j] 和 b_str[j] 是char类型，它们在运算时会提升为int
current_sum += std::abs(static_cast<int>(a_str[j]) - static_cast<int>(b_str[j])); // std::abs 来自 cmath
// 判断当前子串的差值之和是否小于等于V
if (current_sum <= v_val) {
// 如果满足条件，计算当前子串的长度 (j - i + 1)
// 并更新max_length为当前长度和之前max_length中较大的一个
max_length = std::max(max_length, j - i + 1); // std::max 来自 algorithm
} else {
// 如果current_sum已经大于V，那么以i为起点的更长子串的current_sum也必然大于V
// 因此，可以提前终止内层循环
break;
}
}
}
// 输出计算得到的最大连续子串的长度，并换行
std::cout << max_length << std::endl;
return 0; // 表示程序正常结束
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 B卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
