Java 使字符串连续x个A，然后在（n-x）个B之后所需的最小更改

我陷入了Java中一个与问题相关的字符串中。我的逻辑在一些测试用例中运行良好，但不是所有的测试用例。请告诉我以下问题的实际逻辑：

我得到一个n字符的字符串s，它只包含a和B。我可以选择任何索引I并将s（I）更改为A或B。查找您必须对字符串s进行的最小更改数，以使生成的字符串的格式为：AAAAA…..BBBBB。换句话说，我的任务是确定更改的最小数量，使字符串s在开始时有x个A，然后是剩余的（n-x）个B

示例输入如下所示 4. 3. AAB 5. 阿巴阿 1. B 4. 爸爸

第一行：表示测试用例数量的单个整数 对于每个测试用例： 第一行包含一个表示字符串大小的整数 第二行包含字符串

我的代码如下

import java.util.*;
class TestClass {
    public static void main(String args[] ) throws Exception {
        Scanner s = new Scanner(System.in);
        TestClass t = new TestClass();
        int test_case = s.nextInt();
        for(int i = 0; i < test_case; i++){
            int len = s.nextInt();
            String none = s.nextLine();
            String str = s.nextLine();
            int cnta = t.count_ab(str,'A');
            int cntb = t.count_ab(str,'B');
            char c1 = '1';
            if(cnta > cntb){
                c1 = 'A';
            }
            else{
                c1 = 'B';
            }
            int count = 0;
            int c1_count = 0;
            int c2_count = 0;
            if(str.length() > 1){
                String rev = "";
                c1_count = t.cnt_init_a(str, 'A');
                StringBuilder sb = new StringBuilder(str);
                rev = sb.reverse().toString();
                c2_count = t.cnt_init_a(rev, 'B');
                int rem_len = str.length() - c2_count;
                for(int h = c1_count; h < rem_len; h++){
                    if(Character.compare(str.charAt(h), c1) != 0){
                        count = count + 1;
                    }
                }

            }
            System.out.println(count);
        }
    }

    public int cnt_init_a(String str, char c){
        int cnt = 0;
        for(int l = 0; l < str.length(); l++){
            if(Character.compare(str.charAt(l), c) == 0){
                cnt = cnt + 1;
            }
            else{
                break;
            }
        }
        return cnt;
    }

    public int count_ab(String str, char c){
        int cnt = 0;
        for(int g = 0; g < str.length(); g++){
            if(Character.compare(str.charAt(g), c) == 0){
                cnt = cnt + 1;
            }
        }
        return cnt;
    }

import java.util.*；
类TestClass{
公共静态void main（字符串args[]）引发异常{
扫描仪s=新的扫描仪（System.in）；
TestClass t=新的TestClass（）；
int test_case=s.nextInt（）；
对于（int i=0；icntb）{
c1=‘A’；
}
否则{
c1=‘B’；
}
整数计数=0；
int c1_计数=0；
int c2_计数=0；
如果（str.length（）>1）{
字符串rev=“”；
c1_count=t.cnt_init_a（str，'a'）；
StringBuilder sb=新的StringBuilder（str）；
rev=sb.reverse（）.toString（）；
c2_count=t.cnt_init_a（修订版“B”）；
int rem_len=str.length（）-c2_count；
for（int h=c1\u count；h

您的逻辑失败，例如

“baaaaaaaaaaabbbbbbbbbb”

和

“aaaaaaaaaaaaaabbbbbbbbbba”

您应该从忽略所有前导A和所有尾随B开始，因为它们永远不应该被更改

“baaaaaaaaaaabbbbbbbbb”

->

“baaaaaaaaa”

（已删除尾随B）

“aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbba”

->

“bbbbbbbbbbbba”

（删除前导A）

然后将前面的B更改为A，或将后面的A更改为B，以较短者为准

然后重复这个过程