华为OD机试 - 最长回文字符串 - 贪心算法（Python/JS/C/C++ 2024 E卷 100分）

于 2024-10-01 09:06:01 发布
阅读量416 收藏 9
点赞数 13
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od 贪心算法 python
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/142664695
版权

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

如果一个字符串正读和反读都一样（大小写敏感），则称之为一个「回文串」，例如：

  • level 是一个「回文串」，因为它的正读和反读都是 level；同理也是「回文串」
  • art 不是一个「回文串」，因为它的反读 tra 与正读不同
  • LeveL 不是一个「回文串」，因为它的反读 LeveL 与正读不同（因大小写敏感）

给你一个仅包含大小写字母的字符串，请用这些字母构造出一个最长的 回文串 Q，若有多个最长的，返回其中 字典序最小 的回文串。

字符串中的每个位置的字母最多备用一次，也可以不用。

二、输入描述

无

三、输出描述

无

四、测试用例

测试用例1：

1、输入

abczzcccdzz

2、输出

ccdzzadzzcc

3、说明

字符统计：a:1, b:1, c:4, d:1, z:4

左半部分：cczz（取2个c和2个z）

中间字符：a（字典序最小的单个字符）

右半部分：zzcc

最终回文串：cczz + a + zzcc = cczzazzcc

测试用例2：

1、输入

aabb

2、输出

abba

3、说明

字符统计：a:2, b:2

左半部分：ab

中间字符：无

右半部分：ba

最终回文串：ab + ba = abba

五、解题思路

  1. 统计字符频率：
    • 遍历输入字符串，统计每个字符出现的次数。
    • 由于字符串仅包含大小写字母，可以使用一个固定大小的数组（如52个元素，分别对应’A’-‘Z’和’a’-‘z’）来高效地记录每个字符的出现次数。
  2. 构造回文串的左半部分：
    • 遍历所有字符，按照字典序从小到大处理。
    • 对于每个字符，取其出现次数的一半（即能组成的字符对数），并将这些字符按顺序添加到回文串的左半部分。
    • 这样确保左半部分是字典序最小的，同时也保证了回文串的最大长度。
  3. 选择回文串的中间字符（如果有）：
    • 在所有字符中，选择字典序最小且出现次数为奇数的字符，作为回文串的中间字符。
    • 这一步是为了在无法完全对称的情况下，尽可能地增加回文串的长度，同时保持字典序最小。
  4. 构造回文串的右半部分：
    • 将左半部分进行逆序，得到右半部分。
    • 最终的回文串由左半部分、中间字符（如果有）和右半部分组成。
  5. 综合拼接：
    • 拼接左半部分、中间字符和右半部分，得到最终的回文串。

通过高效的频率统计和贪心算法，结合适当的数据结构（数组和StringBuilder），在保证回文串长度最大化的同时，确保了字典序的最小化。这种方法不仅满足了题目的所有要求，而且在时间和空间效率上都表现优异。

六、Python算法源码

# 导入所需的模块
import sys

def construct_longest_palindrome(s):
    # 创建一个大小为52的数组，前26个位置对应'A'-'Z'，后26个位置对应'a'-'z'
    count = [0] * 52
    for c in s:
        if 'A' <= c <= 'Z':
            count[ord(c) - ord('A')] += 1  # 统计大写字母
        elif 'a' <= c <= 'z':
            count[26 + ord(c) - ord('a')] += 1  # 统计小写字母

    left = []  # 回文串的左半部分
    middle = ''  # 回文串的中间字符（如果有的话）

    # 遍历所有字符，按照字典序从小到大处理
    for i in range(52):
        pairs = count[i] // 2  # 计算当前字符可以使用的对数
        if pairs > 0:
            char = index_to_char(i)  # 获取字符
            left.append(char * pairs)  # 将字符对添加到左半部分
            count[i] -= pairs * 2  # 更新剩余的字符数

    # 查找可以作为中间字符的最小字符
    for i in range(52):
        if count[i] > 0:
            middle = index_to_char(i)  # 选择字典序最小的字符作为中间字符
            break

    # 构造右半部分为左半部分的逆序
    right = ''.join(left)[::-1]

    # 拼接左半部分、中间字符和右半部分，得到最终的回文串
    palindrome = ''.join(left) + middle + right
    return palindrome

def index_to_char(index):
    if index < 26:
        return chr(ord('A') + index)  # 转换为大写字母
    else:
        return chr(ord('a') + index - 26)  # 转换为小写字母

def main():
    # 读取输入字符串
    input_str = sys.stdin.read().strip()
    # 调用构造最长回文串的方法
    palindrome = construct_longest_palindrome(input_str)
    # 输出结果
    print(palindrome)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 最长回文串构造程序

/**
 * 构造最长回文串
 * @param {string} s 输入字符串
 * @return {string} 构造出的最长回文串
 */
function constructLongestPalindrome(s) {
    // 创建一个大小为52的数组，前26个位置对应'A'-'Z'，后26个位置对应'a'-'z'
    let count = new Array(52).fill(0);
    for (let c of s) {
        if (c >= 'A' && c <= 'Z') {
            count[c.charCodeAt(0) - 'A'.charCodeAt(0)] += 1; // 统计大写字母
        } else if (c >= 'a' && c <= 'z') {
            count[26 + c.charCodeAt(0) - 'a'.charCodeAt(0)] += 1; // 统计小写字母
        }
    }

    let left = ''; // 回文串的左半部分
    let middle = ''; // 回文串的中间字符（如果有的话）

    // 遍历所有字符，按照字典序从小到大处理
    for (let i = 0; i < 52; i++) {
        let pairs = Math.floor(count[i] / 2); // 计算当前字符可以使用的对数
        if (pairs > 0) {
            let char = indexToChar(i); // 获取字符
            left += char.repeat(pairs); // 将字符对添加到左半部分
            count[i] -= pairs * 2; // 更新剩余的字符数
        }
    }

    // 查找可以作为中间字符的最小字符
    for (let i = 0; i < 52; i++) {
        if (count[i] > 0) {
            middle = indexToChar(i); // 选择字典序最小的字符作为中间字符
            break;
        }
    }

    // 构造右半部分为左半部分的逆序
    let right = left.split('').reverse().join('');

    // 拼接左半部分、中间字符和右半部分，得到最终的回文串
    let palindrome = left + middle + right;
    return palindrome;
}

/**
 * 将索引转换为对应的字符
 * @param {number} index 字符索引（0-51）
 * @return {string} 对应的字符
 */
function indexToChar(index) {
    if (index < 26) {
        return String.fromCharCode('A'.charCodeAt(0) + index); // 转换为大写字母
    } else {
        return String.fromCharCode('a'.charCodeAt(0) + index - 26); // 转换为小写字母
    }
}

// 读取标准输入并处理
const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let input = '';

rl.on('line', function(line) {
    input += line;
}).on('close', function() {
    // 调用构造最长回文串的方法
    let palindrome = constructLongestPalindrome(input.trim());
    // 输出结果
    console.log(palindrome);
    process.exit(0);
});

八、C算法源码

#include <stdio.h>
#include <string.h>

// 将索引转换为对应的字符
char index_to_char(int index) {
    if (index < 26) {
        return 'A' + index; // 转换为大写字母
    } else {
        return 'a' + index - 26; // 转换为小写字母
    }
}

/**
 * 构造最长回文串
 * @param s 输入字符串
 * @return 构造出的最长回文串（需要调用者提供足够的缓冲区）
 */
void construct_longest_palindrome(char *s, char *palindrome) {
    int count[52] = {0}; // 创建一个大小为52的数组，前26个位置对应'A'-'Z'，后26个位置对应'a'-'z'
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (c >= 'A' && c <= 'Z') {
            count[c - 'A'] += 1; // 统计大写字母
        } else if (c >= 'a' && c <= 'z') {
            count[26 + c - 'a'] += 1; // 统计小写字母
        }
    }

    char left[1001] = ""; // 回文串的左半部分
    char middle = '\0'; // 回文串的中间字符（如果有的话）

    // 遍历所有字符，按照字典序从小到大处理
    for (int i = 0; i < 52; i++) {
        int pairs = count[i] / 2; // 计算当前字符可以使用的对数
        if (pairs > 0) {
            char current_char = index_to_char(i); // 获取字符
            for (int j = 0; j < pairs; j++) {
                strncat(left, &current_char, 1); // 将字符对添加到左半部分
            }
            count[i] -= pairs * 2; // 更新剩余的字符数
        }
    }

    // 查找可以作为中间字符的最小字符
    for (int i = 0; i < 52; i++) {
        if (count[i] > 0) {
            middle = index_to_char(i); // 选择字典序最小的字符作为中间字符
            break;
        }
    }

    // 构造右半部分为左半部分的逆序
    char right[1001] = "";
    int left_len = strlen(left);
    for (int i = left_len - 1; i >= 0; i--) {
        strncat(right, &left[i], 1);
    }

    // 拼接左半部分、中间字符和右半部分，得到最终的回文串
    strcpy(palindrome, left);
    if (middle != '\0') {
        int current_len = strlen(palindrome);
        palindrome[current_len] = middle;
        palindrome[current_len + 1] = '\0';
    }
    strcat(palindrome, right);
}

int main() {
    char input[1001];
    // 读取输入字符串
    scanf("%s", input);
    
    char palindrome[2002] = ""; // 需要足够大的缓冲区存储回文串
    // 调用构造最长回文串的方法
    construct_longest_palindrome(input, palindrome);
    // 输出结果
    printf("%s\n", palindrome);
    
    return 0;
}

九、C++算法源码

#include <bits/stdc++.h>
using namespace std;

// 将索引转换为对应的字符
char index_to_char(int index) {
    if (index < 26) {
        return 'A' + index; // 转换为大写字母
    } else {
        return 'a' + index - 26; // 转换为小写字母
    }
}

/**
 * 构造最长回文串
 * @param s 输入字符串
 * @return 构造出的最长回文串
 */
string construct_longest_palindrome(const string &s) {
    int count[52] = {0}; // 创建一个大小为52的数组，前26个位置对应'A'-'Z'，后26个位置对应'a'-'z'
    for (char c : s) {
        if (c >= 'A' && c <= 'Z') {
            count[c - 'A'] += 1; // 统计大写字母
        } else if (c >= 'a' && c <= 'z') {
            count[26 + c - 'a'] += 1; // 统计小写字母
        }
    }

    string left = ""; // 回文串的左半部分
    string middle = ""; // 回文串的中间字符（如果有的话）

    // 遍历所有字符，按照字典序从小到大处理
    for (int i = 0; i < 52; i++) {
        int pairs = count[i] / 2; // 计算当前字符可以使用的对数
        if (pairs > 0) {
            char current_char = index_to_char(i); // 获取字符
            left += string(pairs, current_char); // 将字符对添加到左半部分
            count[i] -= pairs * 2; // 更新剩余的字符数
        }
    }

    // 查找可以作为中间字符的最小字符
    for (int i = 0; i < 52; i++) {
        if (count[i] > 0) {
            middle += index_to_char(i); // 选择字典序最小的字符作为中间字符
            break;
        }
    }

    // 构造右半部分为左半部分的逆序
    string right = left;
    reverse(right.begin(), right.end());

    // 拼接左半部分、中间字符和右半部分，得到最终的回文串
    string palindrome = left + middle + right;
    return palindrome;
}

int main(){
    string input;
    // 读取输入字符串
    cin >> input;
    // 调用构造最长回文串的方法
    string palindrome = construct_longest_palindrome(input);
    // 输出结果
    cout << palindrome << endl;
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）
shen198899的博客
05-02 7万+
华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）华为OD机试-2024年C卷&D卷真题汇总（Java/Python/C++）
华为OD机试 - 分割均衡字符串 - 贪心算法（Python/JS/C/C++ 2024 D卷 100分）
学Java，找哪吒
09-01 422
华为OD机试 2024E卷题库疯狂收录中，刷题。
华为OD机试 - 五子棋迷 - 贪心算法（Python/JS/C/C++ 2024 E卷 100分）
学Java，找哪吒
09-21 1200
华为OD机试 2024E卷题库疯狂收录中，刷题。
华为OD机试 - 万能字符单词拼写 - 贪心算法（Python/JS/C/C++ 2024 D卷 100分）
学Java，找哪吒
09-01 925
华为OD机试 2024E卷题库疯狂收录中，刷题。
华为OD机试 - 报文响应时间 - 贪心算法、位运算（Python/JS/C/C++ 2024 E卷 200分）
学Java，找哪吒
09-12 1159
贪心算法是在每一步选择中都做出当前最优的选择，期望通过局部最优解推导出全局最优解的算法。
华为OD机试 - 学生重新排队 - 贪心算法（Python/JS/C/C++ 2024 E卷 200分）
学Java，找哪吒
09-01 494
华为OD机试 2024E卷题库疯狂收录中，刷题。
华为OD机试 - 恢复数字序列 - 贪心算法（Python/JS/C/C++ 2024 E卷 100分）
学Java，找哪吒
09-18 652
华为OD机试 2024E卷题库疯狂收录中，刷题。
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
热门推荐
算法大师！
03-18 38万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为OD机试 - 停车场车辆统计 - 贪心算法（Java/Python/JS/C/C++ 2024 D卷 200分）
学Java，找哪吒
09-05 696
华为OD机试 2024E卷题库疯狂收录中，刷题。
工作安排 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-25 1977
工作安排 - 华为OD统一考试(E卷) 小明每周上班都会拿到自己的工作清单，工作清单内包含n项工作，每项工作都有对应的耗时时长(单位h)和报酬，工作的总报酬为所有已完成工作的报酬之和。那么请你帮小明安排一下工作，保证小明在指定的工作时间内工作收入最大化。
引入Scrum激发研发体系活力
tonyli288的专栏
09-27 1115
确保团队成员具备必要的技能和协作能力，并保持团队的稳定性，以便于持续改进和高效运作，选择合适的团队成员至关重要。可以通过邀请外部专家授课、内部研讨会等形式，确保全员都能理解和接受这一新的工作方式，提升团队成员对Scrum的认知，并通过宣导活动，营造支持敏捷转型的企业氛围。Scrum的增量式交付和频繁的反馈循环，使得团队能够快速调整方向，响应市场变化和客户需求，提高产品的市场竞争力。Scrum通过明确的角色分工和固定的迭代周期，帮助团队更好地规划和管理工作，减少浪费和瓶颈，提高整体研发效率。
华为OD真题机试-英文输入法（Java）
风信子的博客
09-26 645
华为OD真题机试-英文输入法（Java）
敏感字段加密 - 华为OD统一考试(E卷)
最新发布
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-27 762
敏感字段加密 - 华为OD统一考试(E卷) 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节，只包含大小写字母，数字，下划线和偶数个双引号; 2、命令字之间以一个或多个下划线 进行分割; 3、可以通过两个双引号""来标识包含下划线 的命令字或空命令字(仅包含两个双引号的命令字)，双引号不会在命令字内部出现;请对指定索引的敏感字段进行加密，替换为`******`(6个*)，并删除命令字前后多余的下划线_。如果无法找到指定索引的命令字，输出字符串ERROR.
leetcode刷题day31|贪心算法Part05重叠区间问题（56. 合并区间、738.单调递增的数字、968.监控二叉树）
m0_51007517的博客
09-27 623
贪心最后一节啦，监控二叉树挺有意思的。
leetcode刷题day30|贪心算法Part04重叠区间问题（452. 用最少数量的箭引爆气球、435. 无重叠区间、763.划分字母区间）
m0_51007517的博客
09-26 569
今天的三道题目都是重叠区间的问题。
贪心算法（4）
weixin_74042627的博客
09-25 1162
由于我们希望数组的和尽可能大，因此除非万不得已，我们应当总是修改负数，并且优先修改值最小的负数。因为将负数 −x 修改成 x 会使得数组的和增加 2x，所以这样的贪心操作是最优的。选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2]。选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4]。需要注意的是，nums2的调用方式 nums2[index2[i]]。选择下标 1 ，nums 变为 [4,-2,3]。3.根据下标数组排序后的结果，找到原数组的信息。
【玩转贪心算法专题】56. 合并区间【中等】
sadsasdsdsdasda的博客
09-27 435
按照左边界从小到大排序之后，如果 intervals[i][0] <= intervals[i - 1][1] 即intervals[i]的左边界 <= intervals[i - 1]的右边界，则一定有重叠。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].输入：intervals = [[1,4],[4,5]]输出：[[1,6],[8,10],[15,18]]输出：[[1,5]]
贪心算法介绍
Dirty_artist的博客
09-26 543
贪心算法介绍
华为od机试 - 没有回文串 满分
08-06
华为OD机试题目中的要求是找出一个没有回文串的字符串。所谓回文串，就是正着读和倒着读都一样的字符串。假设我们的输入字符串为s。 首先，我们可以通过遍历字符串s的所有子串来判断是否存在回文串。但是这种方法的时间复杂度较高，不适合大规模的输入。 一个更简单的方法是观察到如果一个字符串中没有重复的字符，那么它一定没有回文串。因此，我们可以先判断s中是否存在重复的字符。如果存在重复字符，那么肯定有回文串。 判断重复字符的方法是使用一个集合Set来存储出现过的字符，遍历字符串s的每个字符，如果字符已经在集合中出现过，就说明有重复字符。 如果字符串s中没有重复字符，那么我们可以得出结论，它一定没有回文串。因为一个没有重复字符的字符串s，它的所有子串都不可能回文。 综上所述，我们只需要判断字符串s中是否存在重复字符即可判断它是否有回文串。如果存在重复字符，那么没有满分；如果不存在重复字符，那么回答正确，得满分。 下面给出一个例子来说明： 假设输入字符串s为"abcd"，由于s中没有重复字符，所以它一定没有回文串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值