在多个回文的情况下找到最长但词典最小的回文

Question

给定一个字符串，我需要找到可以通过从字符串中删除或改组字符来构造的最长回文。如果存在多个相同长度的回文，那么我需要确保以字典顺序最小的回文作为输出。 示例：“adskassda” 预期输出为：“adsasda”

我能够找到最大的回文，但是如何确保在多个相同的最大长度的情况下，按字典顺序最小的一个作为输出？

任何回文字符串都可以分为三个部分——beg、mid和end。对于奇数长度的回文字符串，比如 2n + 1，“beg”由字符串的前 n 个字符组成，“mid”将仅包含 1 个字符，即第 (n + 1) 个字符，“end”将由最后 n 个字符组成的回文字符串。对于偶数长度为 2n 的回文字符串，“mid”将始终为空。应该注意的是，“end”将与“beg”相反，以使字符串成为回文。 我也使用了相同的逻辑。

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

string longestPalindrome(string str){
    map<char,int> frequencyChar;
    for(int i=0;i<str.length();i++){
        frequencyChar[str[i]]++;
    }
    char middle_character;
    string leftStr;
    for(auto it: frequencyChar){
        char currentChar=it.first;
        int frequencyCurrentChr = it.second;
        if(frequencyCurrentChr%2!=0){
            middle_character=currentChar;
        }
        leftStr.append(frequencyCurrentChr/2,currentChar);
    }
    string rightStr(leftStr.rbegin(),leftStr.rend());
    return leftStr + middle_character + rightStr;
}
int main() {
    string str = "adskassda";
    cout<<longestPalindrome(str);
}

我收到“adsssda”但预期是“adsasda”

Answer 1

你只有一个简单的错误。当您要选择中间字符时，当您第一次看到一个频率奇数的字符时，您应该选择它并且永远不要再更新它，因为那将是字典顺序最低的那个。这就是我添加布尔变量mid_char_chosen 的原因，一旦它设置为true，它将不会再次更新。还有一个你没有考虑过的极端情况：如果所有频率都是偶数，那么将没有中间字符，结果将有偶数个字符。所以输出应该省略中间字符。通过这些小的修改，我认为代码可以运行：

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

string longestPalindrome(string str){
    map<char,int> frequencyChar;
    for(int i=0;i<str.length();i++){
        frequencyChar[str[i]]++;
    }
    char middle_character;
    string leftStr;
    bool mid_char_chosen = false;
    for(auto it: frequencyChar){
        char currentChar=it.first;
        int frequencyCurrentChr = it.second;
        if(!mid_char_chosen and frequencyCurrentChr%2!=0){
            middle_character=currentChar;
            mid_char_chosen = true;
        }
        leftStr.append(1*(frequencyCurrentChr/2),currentChar);
    }
    string rightStr(leftStr.rbegin(),leftStr.rend());
    if (mid_char_chosen)
        return leftStr + middle_character + rightStr;
    else
        return leftStr +  rightStr;
}
int main() {
    string str = "adskassda";
    cout<<longestPalindrome(str) << endl;
}

Answer 2

这似乎对我有用，尽管我的测试远非广泛：

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;

int main()
{
    string in("adskassda");
    map<char, int> chars;
    string out;

    for (auto c : in)
    {
        ++chars[c];
    }

    string middle;
    for (auto e : chars)
    {
        if (e.second >= 2)
        {
            out.append(e.second/2, e.first);
            e.second = e.second%2;
        }

        if (e.second && middle.empty())
            middle = e.first;
    }

    string tail(out);
    reverse(tail.begin(), tail.end());
    out = out + middle + tail;

    cout << in << endl;
    cout << out << endl;
}

Answer 3

我在代码中添加了一个小改动 - 一旦我们得到左侧部分，就按字典顺序排序。这在 Java 中可能是必需的。 当我用java编写上面的代码时，我得到的是“asdadsa”而不是“adsasda”

这是Java代码：

import java.util.*;

public class Solution {

    public static String longPalindrome(String a) {
        Map<Character, Integer> map = new HashMap<>();
        for(int i=0; i<a.length(); i++) {
            map.put(a.charAt(i), map.getOrDefault(a.charAt(i), 0) + 1);
        }
        char mid = 0;
        boolean mid_chosen = false;
        StringBuilder left = new StringBuilder();
        for(Map.Entry<Character, Integer> entry : map.entrySet()) {
            if(!mid_chosen && entry.getValue() % 2 != 0) { //odd
                mid_chosen = true;
                mid = entry.getKey();
            }
            //Adding elements to left
            for(int k=0; k<entry.getValue()/2; k++) {
                left.append(entry.getKey());
            }
        }
        //New Step added to sort it lexicographically 
        char[] leftChArr = left.toString().toCharArray();
        Arrays.sort(leftChArr);
        
        StringBuilder leftC = new StringBuilder(new String(leftChArr));
        StringBuilder right = new StringBuilder();
        //adding reverse elements to left
        for(int j=leftC.length()-1; j>=0; j--) {
            right.append(leftC.charAt(j));
        }
        if(mid_chosen == true) {
            leftC.append(mid).append(right);
        } else {
            leftC.append(right);
        }
        return leftC.toString();
    }
    
    public static void main(String[] args) {
        String str = "adskassda";
        System.out.println(longPalindrome(str));
    }
}

可能需要进行一些重构，例如使用 Java 中的现有库在 StringBuilder 中添加重复字符。但是上面的代码提供了解决方案。