Costo perfecto (algoritmo codicioso)

题目描述
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。

交换的定义是：交换两个相邻的字符

例如mamad

第一次交换 ad : mamda

第二次交换 md : madma

第三次交换 ma : madam (回文！完美！)

输入
第一行是一个整数N，表示接下来的字符串的长度(N < = 8000)

第二行是一个字符串，长度为N.只包含小写字母
输出
如果可能，输出最少的交换次数。

否则输出Impossible
样例输入
5

mamad
样例输出
3

Puntos de conocimiento: el algoritmo codicioso
1, el algoritmo codicioso (también conocido como algoritmo codicioso) significa que al resolver problemas, siempre haga la mejor elección en la vista actual. Es decir, sin considerar la optimización general, lo que él hace es solo una solución óptima parcial en cierto sentido. El algoritmo codicioso no obtiene la solución óptima general para todos los problemas, pero puede producir la solución óptima general o la solución aproximada de la solución óptima general para muchos problemas en un amplio rango.
2. Características
La mayoría de los problemas que los algoritmos codiciosos pueden resolver tienen las siguientes características:

⑴ Hay un problema resuelto de manera óptima. Para construir una solución al problema, hay una colección de objetos candidatos: por ejemplo, monedas de diferentes denominaciones.

⑵ A medida que el algoritmo progresa, se acumularán otros dos conjuntos: uno contiene candidatos que han sido considerados y seleccionados, y el otro contiene candidatos que han sido considerados pero descartados.

⑶ Hay una función para verificar si un conjunto de objetos candidatos proporciona una respuesta a la pregunta. Esta función no considera si la solución en este momento es óptima.

⑷ También hay una función para verificar si un conjunto de objetos candidatos es factible, es decir, si es posible agregar más objetos candidatos al conjunto para obtener una solución. Al igual que con la función anterior, la optimización de la solución no se considera en este momento.

⑸ La función de selección puede indicar qué candidato restante es la solución más prometedora para el problema.

⑹ Finalmente, la función objetivo da el valor de la solución.
3. Idea básica
⒈) Establecer un modelo matemático para describir el problema.
⒉) Divida el problema resuelto en varios subproblemas.
⒊) Resuelva cada subproblema para obtener la solución óptima local del subproblema.
⒋) Combine la solución óptima local del subproblema en una solución del problema de solución original.

public class Daijia {
	public static void main(String[] args) throws IOException{
		Scanner scanner = new Scanner(System.in);
	        int len = scanner.nextInt();
	        char[] s = scanner.next().toCharArray();
	        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;
	    }
	     //交换从0位置开始，找到的第一个与0位置数，相同的 到最后一个
	    //交换从1位置开始，找到的第一个与1位置数，相同的 到最后一个 +1;
	    //if (palindrome(s, 0, len - 1)) 
	    //return palindrome(s, a + 1, b - 1);
	    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;
        }         
}