2016年腾讯笔试题之回文字符串

昨天晚上做了腾讯的在线笔试题，其中有一道编程如下：

在考试的时候我并没有想到这题怎么解决，今天的翻看了一些博客，找到了解题思路，并实现了一遍，具体如下：

(1) 申明
首先我想说的是这道题本身是错误的，题目给出的回文字符串的定义的从左往右读和从右往左读是一样的，但是在下面的示例中，字符串”cabebaf”包含的最长回文字符串应该是”abeba”，长度应该是5。但是示例给出的答案是”“abba，长度4。这里，我按正确的题意进行解答。

(2) 思路
这道题的思路就是求原字符串和该字符串的反转后的字符串的【最长公共子序列】，这里使用【动态规划方法】来解决这个问题。

(3) 原理
动态规划方法解LCS问题的原理如下：
考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：
（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；
（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；
（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。
这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。

(4) 实现
引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。

package com.exec;

import java.util.Scanner;

public class LCSRealise
{
    private static final int MAXLENGTH = 1000;
    private static String maxSubstring = "";
    private static Scanner scanner;

    public static void main(String[] args)
    {
        //运用动态规划方法求解LCS时，需要一个数组记录当前的最长公共子序列，这里用c[][]表示
        //还需要一个数组记录搜索方向，这里用b[][]表示
        int[][] c = new int[MAXLENGTH][MAXLENGTH];
        int[][] b = new int[MAXLENGTH][MAXLENGTH];

        scanner = new Scanner(System.in);

        while(scanner.hasNext())
        {           
            maxSubstring="";//为了保证上一次处理结果不影响本次处理，需要将该字符串置空

            String input1 = scanner.nextLine();
            String input2 = new StringBuffer(input1).reverse().toString();//将输入字符串反转        

            int length1 = input1.length();
            int length2 = input2.length();

            LCSLength(input1, input2, c, b);

            maxSubstring =getMaxSubString(length1, length2, b, input1.toCharArray());
            System.out.println(maxSubstring);
        }
    }

    //找出最长公共子序列
    public static void LCSLength(String input1, String input2,int[][] c,int[][] b)
    {
        //初始化c[][]
        for(int m=0; m<input1.length(); m++)
        {
            for(int n=0; n<input2.length(); n++)
            {
                c[m][n] = 0;
            }
        }

        //将两个字符串转换成字符数组进行处理
        char[] inputChar1 = input1.toCharArray();
        char[] inputChar2 = input2.toCharArray();

        for(int i=1; i<=inputChar1.length; i++)
        {
            for(int j=1; j<=inputChar2.length; j++)
            {               
                if(inputChar1[i-1] == inputChar2[j-1])//当两个字符相同时，取写对角的c加上1，且置b为0
                {
                    c[i][j] = c[i-1][j-1]+1;
                    b[i][j] = 0;
                }
                else if(c[i-1][j] >= c[i][j-1])//当两个字符不相同且正上方c大于左边c，则c等于正上方c加上1，且置b为1
                {
                    c[i][j] = c[i-1][j];
                    b[i][j] = 1;                    
                }
                else//当两个字符不相同且正上方c小于左边c，则c等于左边c加上1，且置b为-1
                {
                    c[i][j] = c[i][j-1] ;
                    b[i][j] = -1;   
                }
            }
        }
    }

    //返回最长公共子序列
    public static String getMaxSubString(int m,int n, int[][] b, char[] input1)
    {       
        if(m==0 || n==0)
        {
            return "";
        }

        if(b[m][n] == 0)
        {
            getMaxSubString(m-1, n-1, b, input1);
            maxSubstring += input1[m-1];            
        }
        else if(b[m][n] == 1)
        {
            getMaxSubString(m-1, n, b, input1);
        }
        else
        {
            getMaxSubString(m, n-1, b, input1);

        }

        return maxSubstring;
    }

}

注： 这里可以输入多组数据，数据格式必须与要求格式一致，否则会出错。

(5) 重难点讲解
我认为这道题比较难的地方有两个。第一是思路比较难想到，我开始思考了很久，不知道该怎么判断删除那个字符可以将给定字符串变成回文字符串。当我看到现在这种思路时，感觉很厉害；第二是动态规划方法的实现也是一个比较难的地方，当初在学动态规划的时候只是学习了一些原理，并没有真正用代码去实现，这次实现也参考了别人的代码。对于动态规划方法解LCS问题，一定要先整清楚b数组和c数组记录的信息代表什么意思，这是关键。

(6) 结束语
这是本人的一个实现方式，没有经过OJ平台测试，性能要求和空间限制未必满足要求。当然，这种实现也未必是很好的实现， 如果哪位大神有更好的实现，还请赐教。