字符串中最长回文序列求解

描述：

    当一个字符串中的子串是回文，并且是最长的，则输出，可以有多组最长回文序列。

代码：

import java.util.Arrays;
import java.util.Scanner;

public class 一个字符串里的回文最长 {
    private static int tag=0;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str = in.next();
            int len = str.length();  //获取字符长度
            int[] lflag = new int[len], hflag = new int[len];  //分别存放最长回文的低位和高位，以数组的形式存放相同长度的最长回文标志位
            //int tag = 0;
            for (int i = 0; i < len; i++) {
                int HIGH = len - 1;  //判别高位
                int high = HIGH;
                int low = i;
                while (HIGH > i) {
                    int tag1=getTag();  //得到当前回文数组的长度
                    if (huiwen(low, high, str, lflag, hflag, tag1)) {    //布尔函数不会保存参数值tag，所以使用全局变量赋值的方式
//                        System.out.println(tag);
//                        System.out.println(low+" "+high);
                        break;
                    } else{
                        HIGH--;
                        low=i;  //回到初始状态
                        high=HIGH;  //HIGH向前移位后更新判别位
                    }

                }
            }
            if (hflag[0] == 0)  //如果高位判别数组为0，说明不存在回文
                System.out.println("没有回文！");
            else
                System.out.println("共有" + (tag + 1) + "组最大回文");
            for (int a = 0; a <= tag; a++) {
                if (hflag[a] != 0)
                    System.out.println(str.substring(lflag[a], hflag[a] + 1));
            }

        }
        in.close();

    }

    public static boolean huiwen(int low, int high, String str, int[] lflag, int[] hflag, int tag) {
        int di = low, gao = high;
        while (low < high) {
            if (str.charAt(low) == str.charAt(high)) {  //最低位和最高位相等时继续移动指针
                low++;
                high--;
            } else
                return false;
        }
        if (hflag[tag] - lflag[tag] < gao - di) {  //如果当前判断序列回文比以前的长，则清空标志位数组，并更新
            Arrays.fill(lflag, 0);
            Arrays.fill(hflag, 0);
            tag = 0;
            lflag[tag] = di;
            hflag[tag] = gao;
        } else if (gao - di > 0) {
            if (hflag[tag] - lflag[tag] == gao - di) {  //如果有相同长度的最长回文序列，则加入数组中
                tag++;
                lflag[tag] = di;
                hflag[tag] = gao;
//                System.out.println(str.substring(lflag[tag], hflag[tag] + 1)+"   "+tag);
            }
        }
        setTag(tag); //给数组长度赋值
        return true;
    }
    
    public static int getTag(){
        return tag;
    }
    
    public static void setTag(int tag0){
        tag=tag0;
    }

}

结果截图：