华为OD机试 2024E卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
给定非空字符串S，将该字符串分割成一些子串，使每个子串的ASCII码值的和均为水仙花数。
若分割不成功，则返回0；
若分割成功且分割结果不唯一，则返回-1；
若分割成功且分割结果唯一，则返回分割后子串的数目。
二、输入描述
输入字符串的最大长度为200
三、输出描述
根据题目描述中的情况，返回相应的结果。
四、测试用例
测试用例1：
1、输入
f3@d5a8
2、输出
-1
3、说明
分割成功但分割结果不唯一，可以分割为两组，一组f3和@d5a8，另外一组f3@d5和a8。
测试用例2：
1、输入
AXY
2、输出
0
3、说明
字符串 AXY 可以有两种划分方式：
方案1：AX 和 Y，其ASCII和分别为153和89。153 是水仙花数，但89不是。
方案2：AXY 整体的ASCII和为 234，不是水仙花数。
无法划分为符合要求的子串，因此不能分割成功。
返回 0。
五、解题思路
这道题要求将字符串分割成若干子串，并且每个子串的ASCII码值的和必须是水仙花数。水仙花数是指一个三位数，每一位的立方和等于该数本身。
解题步骤：
- 水仙花数的判定：首先生成所有水仙花数(100到999之间的数字)，并存入一个集合中以便后续快速查找。
- ASCII值和计算：遍历字符串，尝试将字符串划分为多个子串，计算每个子串的ASCII值之和，判断这些和是否为水仙花数。
- 动态规划求解：
- 使用动态规划的思想来解决这个问题。定义一个数组dp[i]，表示到索引i为止的字符串是否可以被划分，并且记录不同划分方案的数量。
- 初始化dp[0] = 1，表示空字符串可以被划分。
- 遍历字符串并尝试从每个位置开始到下一个位置，判断该子串的ASCII值之和是否为水仙花数，如果是，则更新dp数组。
- 结果判断：根据最终的dp值来判断结果：
- 若字符串不能被划分为符合条件的子串，则返回0。
- 若存在多个划分方案，则返回-1。
- 若唯一划分方案成功，则返回子串的数量。
六、Python算法源码
def generate_narcissistic_numbers():
# 生成所有的水仙花数
narcissistic_numbers = set()
for i in range(100, 1000):
hundred = i // 100
ten = (i // 10) % 10
one = i % 10
if i == hundred ** 3 + ten ** 3 + one ** 3:
narcissistic_numbers.add(i)
return narcissistic_numbers
def get_ascii_sum(s, start, end):
# 计算子串的ASCII和
return sum(ord(s[i]) for i in range(start, end))
def partition_string(s):
n = len(s)
narcissistic_numbers = generate_narcissistic_numbers() # 获取所有水仙花数
dp = [0] * (n + 1)
ways = [0] * (n + 1) # 记录不同的划分方案数
dp[0] = 1 # 空字符串可以被划分
ways[0] = 1 # 初始只有一种划分方式
for i in range(1, n + 1):
dp[i] = 0 # 初始化不可划分状态
for j in range(i):
sum_ascii = get_ascii_sum(s, j, i) # 计算从j到i的子串的ASCII和
if sum_ascii in narcissistic_numbers: # 如果子串的ASCII和是水仙花数
if dp[j] == 1:
dp[i] = 1
ways[i] += ways[j] # 更新到i位置的划分方式数量
if dp[n] == 0:
return 0 # 如果无法划分，返回0
elif ways[n] > 1:
return -1 # 如果有多种划分方式，返回-1
else:
return dp[n] # 返回唯一划分方案的子串数量
def main():
# 从控制台读取输入
input_string = input("请输入字符串: ") # 从控制台读取输入的字符串
# 调用partition_string方法计算结果
result = partition_string(input_string)
# 输出结果
print(result)
if __name__ == "__main__":
main()
七、JavaScript算法源码
// 生成所有水仙花数
function generateNarcissisticNumbers() {
const narcissisticNumbers = new Set();
for (let i = 100; i <= 999; i++) {
const hundred = Math.floor(i / 100);
const ten = Math.floor((i / 10) % 10);
const one = i % 10;
if (i === hundred ** 3 + ten ** 3 + one ** 3) {
narcissisticNumbers.add(i);
}
}
return narcissisticNumbers;
}
// 计算子串的ASCII和
function getASCIISum(s, start, end) {
let sum = 0;
for (let i = start; i < end; i++) {
sum += s.charCodeAt(i);
}
return sum;
}
function partitionString(s) {
const n = s.length;
const narcissisticNumbers = generateNarcissisticNumbers(); // 获取所有水仙花数
const dp = new Array(n + 1).fill(0);
const ways = new Array(n + 1).fill(0); // 记录不同的划分方案数
dp[0] = 1; // 空字符串可以被划分
ways[0] = 1; // 初始只有一种划分方式
for (let i = 1; i <= n; i++) {
dp[i] = 0; // 初始化不可划分状态
for (let j = 0; j < i; j++) {
const sum = getASCIISum(s, j, i); // 计算从j到i的子串的ASCII和
if (narcissisticNumbers.has(sum)) { // 如果子串的ASCII和是水仙花数
if (dp[j] === 1) {
dp[i] = 1;
ways[i] += ways[j]; // 更新到i位置的划分方式数量
}
}
}
}
if (dp[n] === 0) {
return 0; // 如果无法划分，返回0
} else if (ways[n] > 1) {
return -1; // 如果有多种划分方式，返回-1
} else {
return dp[n]; // 返回唯一划分方案的子串数量
}
}
function main() {
// 从控制台读取输入
const input = prompt("请输入字符串: "); // 从控制台读取输入的字符串
// 调用partitionString方法计算结果
const result = partitionString(input);
// 输出结果
console.log(result);
}
main();
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
// 生成所有水仙花数
void generateNarcissisticNumbers(bool narcissisticNumbers[1000]) {
for (int i = 100; i <= 999; i++) {
int hundred = i / 100;
int ten = (i / 10) % 10;
int one = i % 10;
if (i == hundred * hundred * hundred + ten * ten * ten + one * one * one) {
narcissisticNumbers[i] = true;
}
}
}
// 计算子串的ASCII和
int getASCIISum(const char* s, int start, int end) {
int sum = 0;
for (int i = start; i < end; i++) {
sum += (int)s[i];
}
return sum;
}
int partitionString(const char* s) {
int n = strlen(s);
bool narcissisticNumbers[1000] = { false }; // 存储是否是水仙花数
generateNarcissisticNumbers(narcissisticNumbers);
int dp[n + 1]; // 记录字符串是否可以被划分
int ways[n + 1]; // 记录不同的划分方案数
dp[0] = 1; // 空字符串可以被划分
ways[0] = 1; // 初始只有一种划分方式
for (int i = 1; i <= n; i++) {
dp[i] = 0; // 初始化为不可划分状态
ways[i] = 0;
for (int j = 0; j < i; j++) {
int sum = getASCIISum(s, j, i); // 计算从j到i的子串的ASCII和
if (sum < 1000 && narcissisticNumbers[sum]) { // 如果子串的ASCII和是水仙花数
if (dp[j] == 1) {
dp[i] = 1;
ways[i] += ways[j]; // 更新到i位置的划分方式数量
}
}
}
}
if (dp[n] == 0) {
return 0; // 如果无法划分，返回0
} else if (ways[n] > 1) {
return -1; // 如果有多种划分方式，返回-1
} else {
return dp[n]; // 返回唯一划分方案的子串数量
}
}
int main() {
char input[1000]; // 假设输入的字符串长度不会超过1000
printf("请输入一个字符串: ");
fgets(input, sizeof(input), stdin); // 从控制台读取输入的字符串
// 去除换行符
input[strcspn(input, "\n")] = 0;
int result = partitionString(input);
// 输出结果
printf("%d\n", result);
return 0;
}
九、C++算法源码
#include <iostream>
#include <vector>
#include <string>
#include <set>
using namespace std;
// 生成所有水仙花数
set<int> generateNarcissisticNumbers() {
set<int> narcissisticNumbers;
for (int i = 100; i <= 999; i++) {
int hundred = i / 100;
int ten = (i / 10) % 10;
int one = i % 10;
if (i == hundred * hundred * hundred + ten * ten * ten + one * one * one) {
narcissisticNumbers.insert(i);
}
}
return narcissisticNumbers;
}
// 计算子串的ASCII和
int getASCIISum(const string& s, int start, int end) {
int sum = 0;
for (int i = start; i < end; i++) {
sum += static_cast<int>(s[i]);
}
return sum;
}
int partitionString(const string& s) {
int n = s.length();
set<int> narcissisticNumbers = generateNarcissisticNumbers(); // 获取所有水仙花数
vector<int> dp(n + 1, 0); // 记录字符串是否可以被划分
vector<int> ways(n + 1, 0); // 记录不同的划分方案数
dp[0] = 1; // 空字符串可以被划分
ways[0] = 1; // 初始只有一种划分方式
for (int i = 1; i <= n; i++) {
dp[i] = 0; // 初始化不可划分状态
for (int j = 0; j < i; j++) {
int sum = getASCIISum(s, j, i); // 计算从j到i的子串的ASCII和
if (narcissisticNumbers.find(sum) != narcissisticNumbers.end()) { // 如果子串的ASCII和是水仙花数
if (dp[j] == 1) {
dp[i] = 1;
ways[i] += ways[j]; // 更新到i位置的划分方式数量
}
}
}
}
if (dp[n] == 0) {
return 0; // 如果无法划分，返回0
} else if (ways[n] > 1) {
return -1; // 如果有多种划分方式，返回-1
} else {
return dp[n]; // 返回唯一划分方案的子串数量
}
}
int main() {
string input;
cout << "请输入一个字符串: ";
getline(cin, input); // 从控制台读取输入的字符串
int result = partitionString(input);
// 输出结果
cout << result << endl;
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
