"Subcadena palíndromo" de la serie LeetCode

647. brochetas kaibunko

Dada una cadena, devuelve cuántas subcadenas palíndromo hay en esta cadena.

Dos subcadenas palíndromas idénticas aparecen en diferentes posiciones y se consideran dos cuerdas palíndromas.

a, aa, aaa, aba, aabaa, abcba se consideran subcadenas palíndromas.

Ejemplo 1 :

entrar

"aaa"

Salida

6

Descripción

a、a、a、aa、aa、aaa

Ejemplo 2 :

entrar

"abcb"

Salida

5

Descripción

a、b、c、b、bcb

Firma de función :

import java.util.*;

public class Solution{
    
    
  	public int palindromeCount(String str){
    
    
      	
    }
}

Tenga en cuenta que el título dice 回文子串, no 回文子序列, que las subcadenas son continuas y que no es necesario que las subsecuencias sean continuas.

Método 1: expansión del centro

La forma más sencilla de calcular cuántas subcadenas de palíndromo hay es enumerar todas las subcadenas de palíndromo, y hay dos formas de enumerar todas las subcadenas de palíndromo, a saber:

• Enumere todas las subcadenas y luego determine si estas subcadenas son palíndromos;
• Enumere todos los centros palíndromos posibles, y luego use dos punteros para expandir hacia los lados izquierdo y derecho respectivamente. Cuando los dos punteros apunten al mismo elemento, expanda, de lo contrario deje de expandirse.

Suponga que la longitud de la cuerda es n. Podemos ver que el primero usará $O(n^2)\; Es$hora de enumerar todas las subcadenas$s[l_{yo}\cdot \cdot \cdot r_{yo}]$ , Reutilizado posteriormente$O(r_{yo}-l_{yo}+1)$ El tiempo para detectar si la subcadena actual es un palíndromo, la complejidad de tiempo de todo el algoritmo es$O\left(n^3\right)$. Este último enumera el centro del palíndromo es$O\left(n\right)$ , el número de expansiones para cada centro palíndromo también es$O\left(n\right)$ , entonces la complejidad del tiempo es$O\left(n^2\right)$. Entonces elegimos el segundo método para enumerar todas las subcadenas palíndromas.

En la implementación, debemos abordar un problema, es decir, cómo enumerar todos los posibles centros palíndromos de manera ordenada.Necesitamos considerar los dos casos de longitud 奇数palíndromo y longitud palíndromo 偶数. Si la longitud del palíndromo es impar, entonces el centro del palíndromo es un carácter; si la longitud del palíndromo es par, entonces el centro son dos caracteres. Por supuesto, puede hacer dos bucles para enumerar el palíndromo de longitud impar y longitud par respectivamente, pero también podemos hacerlo con un bucle. También podríamos escribir un conjunto de observaciones, asumiendo n = 4, podemos enumerar los posibles centros palíndromos:

Número $yo$	Palíndromo centro izquierda posición inicial $l_{yo}$	Posición inicial derecha del centro del palíndromo $r_{yo}$
0	0	0
1	0	1
2	1	1
3	1	2
4	2	2
5	2	3
6	3	3

Como se muestra en la siguiente figura :

De esto podemos ver que una cadena de longitud nn generará 2n-12n − 1 grupos de centros palíndromos $[l_{yo},r_{yo}]$， 其中$l_{yo}=\frac{yo}{2}$，$r_{yo}=l_{yo}+(i\%2)$ . Entonces solo necesitamos comenzar desde$0$ a$2n-1$ Recorra $ i $ para obtener todos los centros palíndromos posibles, unificando así los dos casos de longitud impar y longitud par.

La implementación de Java es la siguiente :

class Solution {
    
    
    public int countSubstrings(String s) {
    
    
        int res = 0;
        int len = s.length();
        for(int i = 0; i <= 2*len-1; i++){
    
    
            int left = i/2;
            int right = i/2 + i%2;
            while(left >= 0 && right < len && s.charAt(left) == s.charAt(right)){
    
    
                left--;
                right++;
                res++;
            }
        }
        return res;
    }
}

• Complejidad del tiempo: $O\left(n^2\right)$
• Complejidad del espacio: $O\left(1\right)$

La entrada y la salida también deben considerarse para la prueba escrita:

El código completo es el siguiente:

import java.util.Scanner;

/**
 * @Author Hory
 * @Date 2020/10/22
 */
public class Palindrome {
    
    
  
    public static void main(String[] args) {
    
    
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        int out = countSubstrings(str);
        System.out.println(out);
    }

    public static int countSubstrings(String s) {
    
    
        int res = 0;
        int len = s.length();
        for(int i = 0; i <= 2*len-1; i++){
    
    
            int left = i/2;
            int right = i/2 + i%2;
            while(left >= 0 && right < len && s.charAt(left) == s.charAt(right)){
    
    
                left--;
                right++;
                res++;
            }
        }
        return res;
    }
}

Método 2: algoritmo de Manacher

El algoritmo de Manacher, también conocido como algoritmo de "carro tirado por caballos", puede resolver un problema de cuerdas con una complejidad de tiempo de O (n) 最长回文子串长度.

Para conocer la solución de Manacher, consulte la solución oficial de problemas de Leetcode.