笔试算法《密码截取》

描述
Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214　。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？

本题含有多组样例输入。

输入描述：
输入一个字符串

输出描述：
返回有效密码串的最大长度

示例1
输入：
ABBA
输出：
4

完整代码

下面提供了两种思路

public class Huawei密码截取 {


    /**
     * 第一种思路：
     * 第一步：将字符串逆序
     * 第二步：求原字符串和逆序后的字符串之间最大公共子串
     *
     *
     *
     * 缺点，速度慢，效率低
     * @param args
     * @throws IOException
     */
//    public static void main(String[] args) throws IOException {
//        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
//        String str = null;
//        StringBuilder builder=new StringBuilder();
//        while (!(str = reader.readLine()).equals("")) {
//            char[] chars = str.toCharArray();
//            char[] arr = str.toCharArray();
//            char[] reverse = reverse(arr);
//            builder.append(maxLength(chars,reverse)).append("\n");
//        }
//        System.out.println(builder.toString());
//    }
//

    /**
     * 第二种思路：
     * 第一步；从字符串开始循环
     * 第二步：循环到每一个位置时，从中间往前后移动坐标判断是否对称
     *
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        StringBuilder builder = new StringBuilder();
        while (!(str = reader.readLine()).equals("")) {
            char[] chars = str.toCharArray();
            int max = 1;
            for (int i = 1; i < chars.length; i++) {
                //AbA  i=1,中间包含字符，从中间字符两边对称坐标开始
                int left = i - 1;
                int right = i + 1;
                int temp=1;
                while (left >= 0 && right < chars.length && chars[right] == chars[left]) {
                    right++;
                    left--;
                    temp+=2;
                }
                if (temp>max){
                    max=temp;
                }
                //AbbA这种i==2，中间没有字符，从对称字符开始移动坐标
                left = i - 1;
                right = i;
                temp=0;
                while (left >= 0 && right < chars.length && chars[right] == chars[left]) {
                    right++;
                    left--;
                    temp+=2;
                }
                if (temp>max){
                    max=temp;
                }
            }
            builder.append(max).append("\n");
        }
        System.out.println(builder.toString());
    }


    public static char[] reverse(char[] chars) {
        for (int i = 0, j = chars.length - 1; i < chars.length && j > 0; i++, j--) {
            if (i >= j) {
                break;
            }
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        return chars;
    }


    public static int maxLength(char[] var1, char[] var2) {
        int max = 0;
        for (int i = 0; i < var1.length; i++) {
            for (int j = 0; j < var2.length; j++) {
                int jIndex = j;
                int iIndex = i;
                int temp = 0;
                while (var1[iIndex] == var2[jIndex]) {
                    temp++;
                    iIndex++;
                    jIndex++;
                    if (iIndex == var1.length || jIndex == var2.length) {
                        break;
                    }
                }
                if (temp > max) {
                    max = temp;
                }
            }
        }
        return max;
    }
}