给定一个字符串，找出使该单词成为回文所需的最小字符数。例子：
ABBA : 0 (already a palindrome) ABB: 1 FAE: 2 FOO: 1
答案 0 :(得分：48)
算法，因为这可能是家庭作业[道歉雷蒙德，这是一个面试问题，而不是作业，因为他的编辑/评论清楚。但是，算法和添加的伪代码仍然有效，我最后添加了一些C代码。
你需要找到字符串末尾最长的回文。可以通过简单地从字符串的开头运行一个指针和从末尾运行一个指针来创建查看字符串是回文结构的算法，检查它们引用的字符是否相同，直到它们在中间相遇。类似的东西：
function isPalindrome(s):
i1 = 0
i2 = s.length() - 1
while i2 > i1:
if s.char_at(i1) not equal to s.char_at(i2):
return false
increment i1
decrement i2
return true
尝试使用完整字符串。如果这不起作用，请将第一个字符保存在堆栈中，然后查看剩余的字符是否形成回文。如果这不起作用，请同时保存第二个字符，然后再从第三个字符开始检查。
最终你会得到一系列保存的字符和剩余的字符串。
最好的情况是，如果原始字符串 是一个回文，在这种情况下，堆栈将为空。最坏的情况是剩下一个字符（一个字符的字符串自动成为回文）和堆栈中的所有其他字符。
您需要添加到原始字符串末尾的字符数是堆栈中的字符数。
要实际制作回文，请逐个将字符从堆栈中弹出并将它们放在回文字符串的开头和结尾处。
示例：
String Palindrome Stack Notes
------ ---------- ----- -----
ABBA Y - no characters needed.
String Palindrome Stack Notes
------ ---------- ----- -----
ABB N -
BB Y A one character needed.
ABBA Y - start popping, finished.
String Palindrome Stack Notes
------ ---------- ----- -----
FAE N -
AE N F
E Y AF two characters needed.
AEA Y F start popping.
FAEAF Y - finished.
String Palindrome Stack Notes
------ ---------- ----- -----
FOO N -
OO Y F one character needed.
FOOF Y - start popping, finished.
String Palindrome Stack Notes
------ ---------- ----- -----
HAVANNA N -
AVANNA N H
VANNA N AH
ANNA Y VAH three characters needed.
VANNAV Y AH start popping.
AVANNAVA Y H
HAVANNAVAH Y - finished.
String Palindrome Stack Notes
------ ---------- -------- -----
deoxyribo N -
eoxyribo N d
oxyribo N ed
: : :
bo N iryxoed
o Y biryxoed eight chars needed.
bob Y iryxoed start popping.
ibobi Y ryxoed
: : :
oxyribobiryxo Y ed
eoxyribobiryxoe Y d
deoxyribobiryxoed Y - finished.
将此方法转换为“代码”：
function evalString(s):
stack = ""
while not isPalindrome(s):
stack = s.char_at(0) + stack
s = s.substring(1)
print "Need " + s.length() + " character(s) to make palindrome."
while stack not equal to "":
s = stack.char_at(0) + s + stack.char_at(0)
stack = stack.substring(1)
print "Palindrome is " + s + "."
对于那些对伪代码不太感兴趣的人，这里有一个C语言中的测试程序。
#include <stdio.h>
#include <string.h>
static char *chkMem (char *chkStr) {
if (chkStr == NULL) {
fprintf (stderr, "Out of memory.\n");
exit (1);
}
return chkStr;
}
static char *makeStr (char *oldStr) {
char *newStr = chkMem (malloc (strlen (oldStr) + 1));
return strcpy (newStr, oldStr);
}
static char *stripFirst (char *oldStr) {
char *newStr = chkMem (malloc (strlen (oldStr)));
strcpy (newStr, &(oldStr[1]));
free (oldStr);
return newStr;
}
static char *addFront (char *oldStr, char addChr) {
char *newStr = chkMem (malloc (strlen (oldStr) + 2));
sprintf (newStr, "%c%s", addChr, oldStr);
free (oldStr);
return newStr;
}
static char *addBoth (char *oldStr, char addChr) {
char *newStr = chkMem (malloc (strlen (oldStr) + 3));
sprintf (newStr, "%c%s%c", addChr, oldStr, addChr);
free (oldStr);
return newStr;
}
static int isPalindrome (char *chkStr) {
int i1 = 0;
int i2 = strlen (chkStr) - 1;
while (i2 > i1)
if (chkStr[i1++] != chkStr[i2--])
return 0;
return 1;
}
static void evalString (char *chkStr) {
char * stack = makeStr ("");
char * word = makeStr (chkStr);
while (!isPalindrome (word)) {
printf ("%s: no, ", word);
stack = addFront (stack, *word);
word = stripFirst (word);
printf ("stack <- %s, word <- %s\n", stack, word);
}
printf ("%s: yes, need %d character(s)\n", word, strlen (stack));
printf ("----------------------------------------\n");
printf ("Adjusting to make palindrome:\n");
while (strlen (stack) > 0) {
printf (" %s, stack <- %s\n", word, stack);
word = addBoth (word, *stack);
stack = stripFirst (stack);
}
printf (" %s\n", word);
printf ("========================================\n");
free (word);
free (stack);
}
int main (int argc, char *argv[]) {
int i;
for (i = 1; i < argc; i++) evalString (argv[i]);
return 0;
}
用以下方式运行：
mkpalin abb abba fae foo deoxyribo
给出输出：
abb: no, stack <- a, word <- bb
bb: yes, need 1 character(s)
----------------------------------------
Adjusting to make palindrome:
bb, stack <- a
abba
========================================
abba: yes, need 0 character(s)
----------------------------------------
Adjusting to make palindrome:
abba
========================================
fae: no, stack <- f, word <- ae
ae: no, stack <- af, word <- e
e: yes, need 2 character(s)
----------------------------------------
Adjusting to make palindrome:
e, stack <- af
aea, stack <- f
faeaf
========================================
foo: no, stack <- f, word <- oo
oo: yes, need 1 character(s)
----------------------------------------
Adjusting to make palindrome:
oo, stack <- f
foof
========================================
deoxyribo: no, stack <- d, word <- eoxyribo
eoxyribo: no, stack <- ed, word <- oxyribo
oxyribo: no, stack <- oed, word <- xyribo
xyribo: no, stack <- xoed, word <- yribo
yribo: no, stack <- yxoed, word <- ribo
ribo: no, stack <- ryxoed, word <- ibo
ibo: no, stack <- iryxoed, word <- bo
bo: no, stack <- biryxoed, word <- o
o: yes, need 8 character(s)
----------------------------------------
Adjusting to make palindrome:
o, stack <- biryxoed
bob, stack <- iryxoed
ibobi, stack <- ryxoed
ribobir, stack <- yxoed
yribobiry, stack <- xoed
xyribobiryx, stack <- oed
oxyribobiryxo, stack <- ed
eoxyribobiryxoe, stack <- d
deoxyribobiryxoed
========================================
答案 1 :(得分：2)
我曾在竞赛中看过这个问题。那时我很难过。
但我认为在与朋友们讨论后我已经得到了这个。问题是要找到插入字符串的最小字符，你需要找到它居中的最长的回文。
取字符串“accaz”
想象一下，字符串accaz是最后插入z的回文acca。所以我们需要在开始时添加另一个z。 另一个字符串：“mykma”
想象一下，这是两个字符k和一个插入其中的mym。所以我们还需要两个字符才能使它成为一个回文。 （回文将是amkykma）。
我用Java编写了一个程序来实现它。
import java.util.*;
import java.io.*;
public class MinPalin{
//Function to check if a string is palindrome
public boolean isPaindrome(String s){
int beg=0;
int end=s.length()-1;
while(beg<end){
if(s.charAt(beg)!=s.charAt(end)){
return false;
}
beg++;
end--;
}
return true;
}
public int MinInsert(String s){
int min=0;
if(isPaindrome(s)){
return min;
}
min++;
while(true){
ArrayList<String> temp=comboes(s,min);
if(hasPalindrome(temp)){
return min;
}
else
min++;
}
}
/*
* Returns an arraylist of strings, in which n characters are removed
*
*/
public ArrayList<String> comboes(String s,int n){
ArrayList<String> results=new ArrayList<String>();
if(n==1){
for(int i=0;i<s.length();i++){
String text="";
for(int j=0;j<s.length();j++){
if(i!=j){
text=text+""+s.charAt(j);
}
}
results.add(text);
}
}
else{
ArrayList<String> temp=new ArrayList<String>();
for(int i=0;i<s.length();i++){
String tempString="";
for(int j=0;j<s.length();j++){
if(i!=j){
tempString=tempString+s.charAt(j);
}
}
temp=comboes(tempString, n-1);
for(int j=0;j<temp.size();j++){
results.add(""+temp.get(j));
}
}
}
return results;
}
public boolean hasPalindrome(ArrayList<String> text){
for(String temp:text){
if(isPaindrome(temp)){
return true;
}
}
return false;
}
public static void main(String[] args)throws IOException
{
System.out.println("Enter the word :");
MinPalin obj=new MinPalin();
BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
int n=obj.MinInsert(r.readLine());
System.out.println("Characters needed : "+n);
}
}
希望这有帮助。
答案 2 :(得分：1)
简单地
static int GetNumForPalindrome(string str)
{
int count = 0;
for (int start = 0, end = str.Length - 1; start < end; ++start)
{
if (str[start] != str[end])
++count;
else --end;
}
return count;
}
static void Main(string[] args)
{
while (true)
{
Console.WriteLine(GetNumForPalindrome(Console.ReadLine()).ToString());
}
}
答案 3 :(得分：1)
这就像找到两个字符串之间的编辑距离，这是一个标准的动态编程问题。你知道字符串的长度，所以将字符串分成两半。您需要找到要添加的最少字符数以将一个字符串转换为另一个字符串。现在可以使用修改后的Edit Distance Algorithms。
使用此算法，您可以在 O（n ^ 2）中解决问题。
答案 4 :(得分：1)
除了Pax的回应。您可以使用“字符串宝石”中描述的线性时间Manacher算法来计算文本中的回文半径。使用它，您可以在线性时间内轻松计算文本末尾最长回文的长度。 我认为这可以将Pax的算法加速到线性时间。
编辑：
Pax的算法假设您只能在字符串的末尾添加字符。 尝试使用BAAABAAB，您将获得BAAABAABAAAB，但如果您只能在结尾或开头添加，可以通过一次插入或BAABAAABAAB将其转换为BAABABAAB。
答案 5 :(得分：1)
python解决方案：
import math
def isPalindrome(s):
return s[:len(s)/2] == s[int(math.ceil(len(s)/2.0)):][::-1]
def numPalindrome(s):
for i in range(len(s)):
if isPalindrome(s[:len(s) - i]) or isPalindrome(s[i:]):
return i
答案 6 :(得分：1)
我认为一个更简单的解决方案是在字符串中找到sub palindrome的开头，通过char移动char。
void makePalindrome(const char* str)
{
int len = strlen(str);
int fp=0, bp=len-1, begin=0, end=bp;
// fp and bp are used to look for matches.
// begin and end represent the begin and end of a possible sub palindrome
while(fp < bp)
{
if(str[fp] == str[bp])
{
fp++; //move back and front pointers.
bp--;
}
else{
if(bp == end) //If no match found yet, just move forward.
{
fp++;
begin++;
}
else
{
begin++; //Since begin isn't feasible, move begin forward
fp = begin; //Reset fp and bp to their respective positions.
bp = end;
}
}
}
int minLenPal = len + begin; //Minimum Length of Palindrome
char a[minLenPal+1];
{ //Build the Palindrome a
strcpy(a,str);
for(int i = 0; i< begin; i++)
a[minLenPal-i-1] = str[i];
a[minLenPal] ='\0';
}
cout<<"For String "<<str<<", minimum characters to be added is "
<<begin<<". Palindrome is "<<a<<endl;
}
这是我的第一篇文章，所以请编辑出任何格式错误。
答案 7 :(得分：0)
创建一个接受字符串和数字n的函数，然后通过添加n个附加字符来尝试将字符串变成回文结构。
对于n = 0 ..什么都不做
对于n = 1 ..附加第一个字符..依此类推
从n = 0运行此函数到初始字符串的长度。
它返回成功的第一个数字n那就是你的答案
答案 8 :(得分：0)
这是我的2美分。可能不是最快的，但是如果你进入Lambdas，它就会很简洁。
static void Main(string[] args)
{
string pal = "ABB";
Console.WriteLine(minPallyChars(pal).ToString());
}
static int minPallyChars(string pal)
{
return Enumerable.Range(0, pal.Length).First(x => IsPally(pal + ReverseStr(pal.Substring(0, x))));
}
static bool IsPally(string value)
{
return value == ReverseStr(value);
}
public static string ReverseStr(string value)
{
return new string(value.Reverse().ToArray());
}
答案 9 :(得分：0)
#include <iostream>
#include<string.h>
using namespace std;
int f(char t[],int i,int j)
{
int c1=0,c2=0,c3=0;
int r;
if(i<j)
{
if(t[i]==t[j])
{
c3=f(t,i+1,j-1);
cout<<"3 "<<c3<<"\n";
return c3;
}
else
{
c1=f(t,i+1,j);
cout<<"c1 "<<c1<<"\n";
c2=f(t,i,j-1);
cout<<"c2 "<<c2<<"\n";
if(c1<c2)
{
c1++;
cout<<"1 "<<c1<<"\n";
return c1;
}
if(c2<c1)
{
c2++;
cout<<"2 "<<c2<<"\n";
return c2;
}
if(c1==c2)
{
c1++;
c2++;
cout<<"4 "<<c1<<"\n";
return c1;
}
}
}
if(i>=j)
{
cout<<"5 "<<c1<<"\n";
return c1;
}
}
int main()
{
int i,j,c=0,n=0;
char s[10];
cout<<"enter the string";
cin>>s;
for(i=0;s[i]!='\0';i++)
n++;
i=0;
j=n-1;
c=f(s,i,j);
cout<<c;
return 0;
}