220178 - 回文字符串 -（vivo2021届秋招）

（java实现）

题目描述：

回文字符串就是正读和反读都一样的字符串，如“viv”、“nexen”、“12321”、“qqq”、“翻身把身翻” 等。
给定一个非空字符串 str，在最多可以删除一个字符的情况下请编程判定其能否成为回文字符串；如果可以则输出首次删除一个字符所能得到的回文字符串，如果不行则输出字符串 "false" 。

输入描述：

一个非空字符串

输出描述：

一个回文字符串，或者 "false" 字符串（如果无法构造出回文字符串的话）

示例1：

输入

abda

输出

ada

说明

删除字符串"abda"中的一个字符 ‘b’ 后，得到 "ada"是一个回文字符串；删除一个字符 ‘d’ 后，得到 "aba"也是一个回文字符串；所以最终输出为 "ada"。

问题分析：

思路一：由于是要删除掉一个字符后再判断是否是回文，可以考虑使用暴力法。具体思路：
从0开始，删除一个字符，再判断剩下的是否是回文。若存在，则输出，否则输出“false”。
思路二：由于涉及回文串，故考虑使用动态规划来实现。
求原字符串和其反串的最大公共子序列（不是子串，因为可以不连续）的长度，然后用原字符串的长度减去这个最大公共子串的长度即可得到要删除的字符数。再判断公共长度与与原有长度的差值，若差值大于1，则不存在；若差值为1，则删除对于的字符；若差值为0，则删除中间的字符。

相关知识：

参考代码：

思路一：

import java.util.*;
public class Main {

    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        String line = input.nextLine();
        boolean flag = false;
        for (int i=0; i<line.length(); i++)
        {
            String str = line.substring(0,i)+line.substring(i+1,line.length());
            if (isPalindrome(str))
            {
                System.out.println(str);
                flag = true;
                break;
            }
        }
        if (!flag)
            System.out.println("false");
    }

    public static boolean isPalindrome(String str)
    {
        char[] ch = str.toCharArray();
        boolean flag = false;
        int i=0, j=ch.length-1;
        while (i<j)
        {
            if (ch[i] != ch[j])
            {
                flag = true;
                break;
            }
            i++;
            //j++;
            j--;
        }
        if (flag)
            return false;    // string is not a palindrome
        else
            return true;
    }
}

思路二：

import java.util.*;
public class Main {

    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        String str1 = input.nextLine();
        String str2 = new StringBuilder(str1).reverse().toString();
        int len = str1.length();
        int[][] dp = new int[len+1][len+1];
        boolean[][] flag = new boolean[len+1][len+1];
        int index = 0;
        for (int i=1; i<=len; i++)
        {
            for (int j=1; j<=len; j++)
            {
                //if (str1.charAt(i) == str2.charAt(j))
                if (str1.charAt(i-1) == str2.charAt(j-1))
                {
                    dp[i][j] = dp[i-1][j-1] + 1;
                    flag[i][j] = true;
                }
                else
                {
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                    index = i-2;
                }
            }
        }
        if (len-dp[len][len]>1)
            System.out.println("false");
        else if (len==dp[len][len])
        {
            int mid = len/2;  
            System.out.println(str1.substring(0,mid)+str1.substring(mid+1,len));
        }
        else if (1 == len-dp[len][len])
        {
            if (str1.charAt(len-1) == str2.charAt(len-1))
            {
                StringBuilder res = new StringBuilder();
                for (int i=0; i<len; i++)
                    if (i!=index)
                    {
                        res.append(str1.charAt(i));
                    }
                System.out.println(res.toString());
            }
            else
            {
                System.out.println(str1.substring(0,len-1));
            }
        }
    }
}