完美的代价

蓝桥杯基础练习：

问题描述

　　回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)

输入格式

　　第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
　　第二行是一个字符串，长度为N.只包含小写字母

输出格式

　　如果可能，输出最少的交换次数。
　　否则输出Impossible

样例输入

5
mamad

样例输出

3

【分析】：首先要判断该字符串能不能变成回文串，如果不能你去进行操作就是在浪费时间了，所以判断依据就是统计该字符串中的各字符个数为奇数的个数，如果为奇数的字母个数大于1个，说明整个字符串到最后会有两个落单的字母，肯定不能凑成回文串了，所以这种情况直接“Impossible”就可以了。如果能成为回文串的话，就写一个函数进行递归求解。

import java.util.Scanner;

public class Main{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        String string = sc.next();
        if(isPossible(string)){    
            System.out.println(getResult(string));
        }else {
            System.out.println("Impossible");
        }
        sc.close();
    }
    
    private static boolean isPossible(String str){
        int odds = 0;
        boolean ans = true;
        int[] temp = new int[26];
        for(int i=0;i<str.length();i++){
            temp[str.charAt(i) - 'a']++;
        }
        for(int j=0;j<26;j++){
            if(temp[j] % 2 == 1){
                odds++;    
            }
        }
        if(odds > 1){
            ans = false;
        }
        return ans;
    }
    
    private static int getResult(String str){
        int length = str.length();
        if(length == 1 || length == 2){
            return 0;
        }
        
        int temp = str.lastIndexOf(str.charAt(0));
        if(temp == 0){    //说明这个是除了自己没有找到相同的字母与之匹配了，所以这个需要放到整个字符串的中间。
            return length/2 + getResult(str.substring(1,length));
        }else {
            StringBuffer sb = new StringBuffer(str);
            sb.deleteCharAt(0);
            sb.deleteCharAt(temp);
            return length-1-temp + getResult(sb.toString());
        }
    }
    
}

【PS】：就这样就结束了吗？来看个样例！

输入：
6411
sappytuikoulwwzcdyykjigdynflzrbgffqfkpzzsbfnampapwsmsgtqylggqykoyqltfefkbytkreaybkiqamzxpoefmewfkxezuyqqdqtafgliflgfhhvcwcidfxfxymykkiweifeoceeqhzmiemldhpfgpwwehwrnrudplsgxemvcukkjnbijaqodifjsfbdbonepsdkxegwoqfcyartakjwssimelxzwvpangaknsdravlvryyolpikgwpcolpfafsjzurfwpwookfzeadyhmsyoycmtggjvdmkssejwfwoxpcfkuxvzrbusnqdctlkfjqkuuzqaqdojgknyjcdwdiknjzgswqerddyplpdqjmlqwvvkfsnrampmzokzcozdtxyzottpktwkuyrbmcargygsvkcqzkhgzcxiigabicpfdbtybrcshsimfjxlaxhefnjghcvxgxnigpjpyxninaivtmhaszwxnxbudyiqffzzasnqgxrwhpoerkrdblqwaykczhdoptnhjzadlcrvndstsswrpwdqfumramzttajjwuamhzkxkjmwjuluzikkrxiybukxmzomcyyvpdxjlcnanpccyulztofgeylmtcgucpgkpejiwoonbwmkmcrsntutviafkpqrrrjqqlgefopsvtrwajxykjlzejmeystpuhceyeydobmosbvhwjlrwqtsflfqwsfxieovpzfckvlmlrftvwkqtehuedvgmxasfqvgtcagzbginipwpmrtzpaqllvkmgsqifgbskpakafgdfygwmexattappgcphdbztwbrtjcywonvweooypwebqucjcofuuqcgwoglndynyhvvafpjksdtayrtfxomihonqbplkomlfeykmqkcixwjznwcoshwmjfvduuymrmqrzxvivjtbbvyxwjlzfantrlexmmzayhgizsrknfpruzfydqngctgzhqdrjskodqndepjctylqezpoglzmterqyvqbnkcafnuyqlhcjfulivmloeppzasrccbkuliwsibwmmqxiagkkgoddduokpesjkxjssavowtcojymmadnsyxejdfhwyjpeypdlgptfbfsursrnapnhlngynsrliudvdkghpcitdpeztkshhtrmvdhbriimbfzjfaidpgoeboixeeclpktdnazxwgfzpywjsnrzxhhxqdekxmakvcmhfsszxgelwzsznngmsnxmwvbhqbcjfyfxrnssaqyulymlsffrwqbqxebezmekkphwpdhvpxmjelrbktvvwkylxrseejefeprjqrgojokwrzmtztptdzjiwxwlzqrrpynzflrqnskrxgtpdyhpulotnbpxbyhfnjafgqwfxlwasvbbkcezuomworxjaspxwbwlecuwegzjvmojvedsnauaagbjflwexvwujjktesgwkwvgajevghsvntornhlihpxnoflslgnfxempzpvzysnuloresuhxdkjxrjpororzobkmxccxfvoqcnipbwfaiwaiyjqwzlbkkemthmvwxletndxmzjwdjgfharrsregupxtpfzxvquikiqpxjnpquzzddlntsnbitaestbtjxyglrkgriuddweiejdyomelhsbfyxrgqpulwwqpiewpylhwekejwmtovliclxkbikubvmbtfwzkzbtpxrehkfyvxkmappaddiwcczwtypoitaabayepamoxldhmeezjxaqptyhlvnzsplbtbibrcrlkblnqbdlbwnvmaioyqpxbaeijbhavvxnspjqtwcolomyyxaiblhizmexplkpqsjibbpxpcegmzliadlonijvpnfyzowushrwrzvridzzdklnrvdlrpqeteoyehelovnicjzfphmswzncxxkmegvgohwdpecpavlgjclucqnuwdxzrtdrevjwmggryqfmzplcwuiuggtglgfveiuuzjkladcnfhfkqheudqqbaawjxeogsbabwxzvwopvzsbatxbucqvenhcnbuvmfvkfizmclwmiciqagvrwsufoejbdwamdzefypypuahjeobovoebtylwrpigmncfxjychvcpxwmfjqxkytpawxgubbqgwtacdakdytmpoenfhfmngnccdcwoxrwzqhnbexmsespdduyqxyccwywdipsrkfbhvrjafasunmlbbmeleljznitrqsudmccicvdgelianrbyozqfnemvgzvejtynztygmfxlvwaoizejelyzkfmkblxhfxzimsybwwlpbaeswojyqoolebmjxvaulwklllftzyxtnmhhpqolzbbvnzeflsyzffikgnqpfyyoxgchrsosdomacmlfsmvztstrmprsukxchlxpgoiimcvueeysmrethmokudcwnoxdyxaojsyjhcorscllxbrdmqanyywdencqvrxrykwapneqbdevsxqnkxpshrwgvuctrbcvmmyyqjtdrnsyxojskbyboiqoaqsusmcanpjowfwdksedafofebqfhlrcmaoxictcxhhmgeueidjjvkxxdhvaaqwqkvrfknfvnvqseehddbtlwyhobibwonloliqiclvkxpvmvfiopxjwuwmdqtmgrqewefanwyutcjdzgrkgjowgpvwbvdcaarlobwgwjnwdrfajdmiajwxwzmfmjdgeeygzowlpmbyeedpaqathcmcggymlpjwmoxgttwyccpyttsybjnrdifgspavzqdjqxmnumlofzdhwqmmquymmxidfmigceboxnehkzlvpsbfopgxwqjkdzaibgimxicfrwfficnkskmzbazoaqkzyscsbvirtgisqdzopzhbtpnvrkweuwrlhilyohmgakvxooyipimkbncwfhiypmjhuqraoptmdtknqulhuqfahnawqqhxgrqqyqxiprjcbzphoqqnoydultlarooiopayhvjzzobjpcwkkarhshkvmspojljxpvybnkvabphvgcedlxmutprexubxubzsrwnjeuockmriewwskwwjrsjnxchcloutqzisltrjvohqckhsldvypwylhtejztdshjntmwvnygyxnnkrwqfoizszraevalfokmfimneyqwnpvtomyrecdvadthbxzcjdzdbinlzxwqdaomljbhlvxpzmelcjtxudcdwgvqsdumypzcujeqajsbutfmyrqzmhuelyaupuajrazsenjvqeoadfogwwfiykkoaxabhihtgcyxkfneejwdpxwrhygsmhtgwosheaizmngyikxaihfkzyqbvxqomkjpvejaqfmkbxqnirylwojablxrvarvuppooywbyheqvodvfhlyvvwdzkrkxlqjrkgnxqjrazxqqjycnjthwjdxarcipcfkcufzsfihtfirdxipfizkrukrcjfoiehpencmzkjxgerwervczxfozdhalwsrgpyjuzhcktrwjmlwwujqrqpryhbmvuekwniryylpjcibbdggiuhwbsopbqwbhapnkxyuezsrhxaagyuiyyvjyrgqpngzkrugfydbhekbbgfkhqantesdprcogqclthredomaikgvmizqfgsreizjlaycdhxkjzfoevcohckyhoyjprjjxzqvgbeabwdesacbwgawepspblxbxijihnnewnigrmkdtrpmqnufnkqpylxsxhlmnxptoiscfjezkbywluexexjeaeghftswkaxqtfvalzbsbhuldhfmhwjhvlxcwdelnrzxuhgtigyzxokknwwskblroubrvmuhzhomxqothcqqasccokuyfrvhbpunsmadljpuvtacosgbdfjwzmzsrnbyyzljzelaimgdjzsxmsvkdbswceueezblglqdvvkxtpcujmwrlnuikouguteneyubdozcirisnielfsfaaeeclkhmrcsiaignolqijovzuofzfwxknmunybiteudqwmcfmmraxmbgqnbrepsawlitmohassjctziwssussdgqekmomazkehuotdquywontmcqfdjytkobszshanaahybyztonzfsxagzgypfwrbvycsfhuwkpyiknzjbtjyswkyyqfbjgxrpdvftuvzazldeyvarqokrohakuiynmvhzlvpfcpmvtuswqpukaigiltiptdqwiwnkorwpwfavblhyxcayanqghpsxhtxxmomfusfxychdoipvhlkhyhquodgicvxpleclzdlpjnqrhzsqgywndrngzdhddlfrdfdkpxygsyivnkyllgdgjqmnjkqoaggyigupeszaaiwcaxpsmdlbncpbewgootnxflxkyjdtwfhlneoebtusajmpcunolyoljzvdwlblkufvgfwmfnujzlgibgekepizmkvrgaosdksjztgrggivjnjutjiupezyliytifpmcwlepaflxrvkmxmfykfzlcoyagtwaapsjsisfleewvcxhacdnoutiaswmrrowspudxfyirdrvzgoxwfddbjesttyiegorizayjtptmqjawdlvexavcqyxoyfofhlntiknsfhyyxowhydwliowfxvprmvdhhlswcaohxydptlhzqolghsumdfejejtxdxrsoxgdauujhqmoekvwngwykeisutbknmyrlwemprzylvwpfipcgxivtardnyeelkkoegcmmbbqxfwinjmemhmujzqsdwwvubnpklxfavwfucegnyfkjdhvdvfugrgmieiyqkvgmsxmndyagiileudwjmvkamrfiymbvxnbtxondjyezoxgzfgczkzqbhpzqljridyekktyfdxyjanxvbfxggbiyqiflxaffrhcgrnpeqsunhysnaqrgmkpfnvnjrahhiuqwwrmjpcfztnmlwtwrxuiwdsufrffqbweglkbiihkqtajmdxrckljolwvaqlsssldowrstawykzqycmvhbhxdehodxigehgwivduygijbcdxhhgmdcemedapvuclhbgddgecvehtbnhgktvwlpostvfrutwvnukuwqnmyyviipmzjvqkgxocvqipyrdbhhdwucfybxglygbecdiudnfbcfgzxuzvadjxiufpiyxfpcgnrskzoobfofqqkymtywnmaalypgvfthfbugmwaqihcgiypbvqqulafbftsgcxsffdblbcojgwqlihahqvlumlwhiclpkgnwoysxdmjontcxelxxtadafrtkqelplpstokagittwitvwagelqqkmjgwabtcidjizzzdqboagubirutfcrmiuydyduqbfbqzhnuqguwdkierojpoofjynxixxfpzrmmppiupzllrgynngccazhqmosjipseoibjcosxunwilqvehiciqchktcarjryoxtnyydejyedxwtktqmdehfygrurccdaromvcwpgwbmwrichzkembthbrvdzhnqddkvxhemljdkgciictkuhvtehmqugtskgpejfcpqneorqvssszwbqlukcmvngrvjfxcksjzgrxdihjdrpqkrhdiqiiiyrfztyyhejleoejnxndmozvtaicuhmzzceotkuivpfsalmrkawxyuexpnsdmtedzkvvuowoemdlodjhfbbmohaxezaiklecwpqakjgojgxsucnzgbdmqgeuaowqgqjuhbyzeeuhhuxihiwngtwlceemqchcfsmyxgaryybfmlmsultghnngalgvnslwogyeyxvqlaxoiphskxhtsozfqdvsblhgymfdfnwhuirdxsdqfhsdpxudeopgehsreklavccriotdkewclthbpccmrxycpcshxnrvrfzpwbobxkjyprgtpqjfacpyvtvwmtfltejbboxgjfqeldjqualijjfnkbrcqsydgifrarjqoomkfrjtnnlpcsioqynqbcgylmyhdzezctxgbohwuqoslysfsmwgnywsghhprdykxyhzcejzddhhfabsksyhovhusvlkyomxevrgkecpqizlptieorihsrhrhclpscxmitxzidfrxpdayqegibbfagzlwhnvsefzeadilrptxgumndxjejxvbqkymrjysxgejrocdwnufhbroxbnlsaeezlgejogqfdmwsqaqjzbpmcyppwodangvdtspwjxnniitwwojcxmhmzkvcydfelokrpthauxmdodlvfyeuqalcypoirtmojnkjhtofwcdmwlmejizqttmzrbmzilpissdrxuebstfpgbnfoilbizrsdrydoofyqcbqyeygctvblglqkfnouhgbbivzmwtioxcmoxlhxhdxbvwlyainlaryjhebvmlzzbguwtyplbmzqfkfpjvrsxjoaxgzolyvbyhgzaoxape

输出：
541435

看到这个样例，输入到程序中抛出了异常　　java.lang.StringIndexOutOfBoundsException: String index out of range: 6176

所以我们输入就不能使用String 来接收这个很长的字符串了，要想个别的办法才行。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class 完美的代价 {
     
    public static void main(String[] args) throws IOException{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int len = Integer.parseInt(reader.readLine());
        char[] s = reader.readLine().toCharArray();
        reader.close();
        if (palindrome(s, 0, len - 1)) {
            System.out.println(cnt);
        } else {
            System.out.println("Impossible");
        }
    }
    
    private static int cnt = 0;
    private static boolean haveMiddle = false;
    
    private static boolean palindrome(char[] s, int a, int b) {
        if (b <= a) {
            return true;
        }

                // 从最后的位置开始遍历字符串
        for (int i = b; i > a; i--) {
            if (s[a] == s[i]) {
                exchangeTo(s, i, b);
                cnt += getExchangeTimes(i, b);
                return palindrome(s, a + 1, b - 1);
            }
        }

                // 如果没有出现过中间字符
        if (!haveMiddle) {
            haveMiddle = true;
            cnt += getExchangeTimes(a, s.length / 2);
            return palindrome(s, a + 1, b);
        }
        return false;
    }
    
    private static int getExchangeTimes(int a, int b) {
        return b - a;
    }
    
    private static void exchangeTo(char[] s, int a, int b) {
        char temp = s[a];
        for (int i = a; i < b; i++) {
            s[i] = s[i + 1];
        }
        s[b] = temp;
    }
    
}