蓝桥杯BASIC-19(完美的代价)

/*问题描述
　　回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)
输入格式
　　第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
　　第二行是一个字符串，长度为N.只包含小写字母
输出格式
　　如果可能，输出最少的交换次数。
　　否则输出Impossible
样例输入
5
mamad
样例输出
3
*/

package testing_02;

import java.util.Scanner;

public class test_19 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Scanner input=new Scanner(System.in);   
     Scanner input1=new Scanner(System.in);  
     int num=input1.nextInt();
     String str=input.nextLine();
     char a[]=str.toCharArray();
     int flag=1;
     int count =0;
     int c=-1;
     int index=num-1;
     for(int i=0;i<index;i++){
         for(int j=index;j>=i;j--){
             if(i==j){
             if(num%2==0||c!=-1){ //如果n为偶数或者a[i]不是唯一一个单个无相同字符
                 flag=0;
                 break;
             }
             c=1;
             count=count+num/2-i;
             break;
             }

            if(a[j]==a[i]){
            for(int k=j;k<index;k++){
                a[j]=a[j+1];
            }
            a[j]=a[i];
            count=count+index-j;
            index--;
            break;
             }
         }
         if(flag==0){break;}
     }
     if(flag==0){
        System.out.println("impossible");
     }else{
         System.out.println(count);
     }  
    }
  }

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            int n = Integer.parseInt(scanner.nextLine());

            String str = scanner.nextLine();
            char[] chs = str.toCharArray();

            int[] count = new int[26];
            char ch = '0';
            int oddchar = 0;

            for (int j = 0; j < chs.length; j++) {
                int index = chs[j] - 'a';
                count[index]++;
            }

            for (int i = 0; i < 26; i++) {
                if (count[i] % 2 != 0) {
                    oddchar++;
                    ch = (char) (i + 'a');
                }
            }

            if (oddchar > 1) {
                System.out.println("Impossible");
            } else {
                int result = exchange(chs, n, ch);
                System.out.println(result);
            }
        }
    }

    private static int exchange(char[] chs, int n, char ch) {
        int count = 0, i, j, k;
        for (i = 0; i < n / 2; i++) {
            if (chs[i] == ch) {
                for (j = i; j < n - i - 1; j++) {
                    if (chs[j] == chs[n - i - 1]) {
                        break;
                    }
                }

                count += j - i;

                for (k = j; k > i; k--) {
                    chs[k] = chs[k - 1];
                }
                chs[i] = chs[n - i - 1];

            } else {
                for (j = n - i - 1; j >= i; j--) {
                    if (chs[j] == chs[i]) {
                        break;
                    }
                }

                count += n - i - 1 - j;

                for (k = j; k < n - i - 1; k++) {
                    chs[k] = chs[k + 1];
                }
                chs[n - i - 1] = chs[i];
            }
        }
        return count;
    }
}