字符消除

字符消除

时间限制:1000ms

单点时限:1000ms

内存限制:256MB

描述

小Hi最近在玩一个字符消除游戏。给定一个只包含大写字母"ABC"的字符串s，消除过程是如下进行的：

1)如果s包含长度超过1的由相同字母组成的子串，那么这些子串会被同时消除，余下的子串拼成新的字符串。例如"ABCCBCCCAA"中"CC","CCC"和"AA"会被同时消除，余下"AB"和"B"拼成新的字符串"ABB"。

2)上述消除会反复一轮一轮进行，直到新的字符串不包含相邻的相同字符为止。例如”ABCCBCCCAA”经过一轮消除得到"ABB"，再经过一轮消除得到"A"

游戏中的每一关小Hi都会面对一个字符串s。在消除开始前小Hi有机会在s中任意位置(第一个字符之前、最后一个字符之后以及相邻两个字符之间)插入任意一个字符('A','B'或者'C')，得到字符串t。t经过一系列消除后，小Hi的得分是消除掉的字符的总数。

请帮助小Hi计算要如何插入字符，才能获得最高得分。

输入

输入第一行是一个整数T(1<=T<=100)，代表测试数据的数量。

之后T行每行一个由'A''B''C'组成的字符串s，长度不超过100。

输出

对于每一行输入的字符串，输出小Hi最高能得到的分数。

提示

第一组数据：在"ABCBCCCAA"的第2个字符后插入'C'得到"ABCCBCCCAA"，消除后得到"A"，总共消除9个字符(包括插入的'C')。

第二组数据："AAA"插入'A'得到"AAAA"，消除后得到""，总共消除4个字符。

第三组数据：无论是插入字符后得到"AABC","ABBC"还是"ABCC"都最多消除2个字符。

样例输入

3
ABCBCCCAA
AAA
ABC

样例输出

9
4
2

package Qin.Coding3_12;

import java.util.Comparator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

/**
 * Created by Qin on 2020/3/21.
 */
public class LetterElimination {

    public static void main(String[] args) {
        String string ;
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        String[] strings = new String[T];
        int A, B, C = 0;
        for (int i = 0; i < T; i++) {
            string = scanner.next();
            strings[i] = string;
        }

/**
 * 注意：成批输入时，不能将输入循环和操作循环写在一个循环里，不然结果格式会很奇怪
 * 解决思路：将两个循环分开写，用一个容器作为桥梁
 */
        for (int i = 0; i < T; i++) {
            C = 0;

            string = strings[i];
            //输入字符串转StringBuilder
            StringBuilder sb = new StringBuilder(string);


            for (int j = 0; j < sb.length() + 1; j++) {

                //插入字符“A”,"B","C"
                for (int k = 0; k < 3; k++) {
                    switch (k) {
                        case 0:
                            sb.insert(j, "A");
                            break;
                        case 1:
                            sb.insert(j, "B");
                            break;
                        case 2:
                            sb.insert(j, "C");
                            break;

                    }

                    A = sb.length();
                    Set<Integer> set = new TreeSet(new MyComparator());

                    //重复消除连续重复字符
                    do {
                        set.clear();
                        char[] a = new char[sb.length() + 1];
                        sb.getChars(0, sb.length(), a, 0);

                        //找出连续重复字符的位置
                        for (int l = 1; l < a.length; l++) {
                            if (a[l - 1] == a[l]) {
                                set.add(l - 1);
                                set.add(l);
                            }
                        }

                        //根据索引删除所有重复字符
                        for (Integer x : set) {

                            /**
                             * 注意:每次删除，都会导致sb中字符位置改变
                             * 解决思路：从后往前删除
                             */
                            sb.deleteCharAt(x);
                        }

                        //满足条件就循环
                    } while (set.size() != 0);

                    B = sb.length();
                    C = Math.max(C, A - B);

                    //重新new StringBuilder对象
                    sb = new StringBuilder(string);
                }
            }
//            System.err.println(C);//为了校验数据方便，结果被坑了43分钟
            System.out.println(C);
        }
    }
}
class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        //降序排列
        return o2.compareTo(o1);
    }
}