Cómo resolver el problema 144C en Codeforces

2 cadenas A y B si y solo si el recuento de cada letra (‘a’ … .’z ‘) en ambas cadenas es el mismo. De ello se deduce que ambas cadenas serán de igual longitud. Ahora se nos han dado algunos caracteres comodín en la cadena A. Un carácter comodín puede aumentar el recuento de cualquiera de las letras en A en 1.

Ahora,
Permítanos almacenar el recuento de cada letra en la cadena p en una matriz de pc []. Supongamos que tenemos el recuento de cada letra para la subcadena a partir del índice i de la cadena s (que tiene la misma longitud que la de p) en la matriz sic [], también tenemos el número de caracteres comodín en la subcadena dada. Podemos verificar fácilmente si pueden convertirse en anagramas o no.

bool check(int sic[], int wcard) { int diff = 0; // diff is the count of wild card characters required to make the anagram for(int i=0; i pc[i]) return false; // if count in p is more, we add it to the number of wild chard characters required else diff += (pc[i] - sic[i]); } return (diff <= wcard); } 

La pregunta ahora es cómo actualizaremos la matriz sic [] y wcard. Observe que al pasar de la iteración i-1 a i, solo necesitamos eliminar s [i-1] (o decrementar wcard) y agregar s [i + p.length () – 1] (o aumentar wcard). Usando esto…

 i=1; while(i + p.length() - 1 < s.length()) { // removing s[i-1] if(s[i-1] == '?') wcard--; else sic[ s[i-1]-'a' ]--; // adding s[i + p.length() - 1] if(s[i + p.length() - 1] == '?') wcard++; else sic[ s[i+p.length()-1]-'a' ]++; if(check(sic, wcard)) ans++; i++; } 

Al principio, tendremos que hacer las matrices sic [] así como pc [].

 memset(pc, 0, sizeof(pc)); for(int j=0; j<p.length(); j++) pc[ p[j] - 'a' ]++; int sic[26] = {0}; int ward=0; if(p.length() <= s.length()) { for(int j=0; j<p.length(); j++) { if(s[j] == '?') wcard++; else sic[ s[j]-'a' ]++; } } if(check(sic, wcard)) ans++; 

aquí está mi código espero que entiendas

#include
#include

int a [30] = {0}; /// matriz de hash para la primera cadena
int b [30] = {0}; /// matriz de hash para la segunda cadena

int check (int no) /// esto verificará si las dos cadenas son anagramas
{// el no aquí es el no de? obtienes cada iteración l2 /// de la primera cadena
int i, temp = 0;

para (i = 1; i <= 30; i ++)
{
si (a [i] temp + = b [i] -a [i]; temp es la diferencia general
}

si (temp == 0)
retorno 1;

if (temp <= no) // si es posible eliminar la diferencia con la ayuda de "?"
retorno 1;

devuelve 0;

}

int main ()
{
char f [100001]; //primero
char s [100001]; //segundo

scanf (“% s”, f);
scanf (“% s”, s);

int i, j, ans = 0;

int l1 = strlen (f);
int l2 = strlen (s);

if (l2> l1) // en caso de que la segunda cadena sea grande
{
printf (“0 \ n”); devuelve 0;
}

para (i = 0; i {j = (s [i] – ‘0’-48); b [j] ++;} // haciendo hash de primero

int cnt = 0;

for (i = 0; i {if (f [i]! = ‘?’)
{j = (f [i] – ‘0’-48); a [j] ++;}
más
cnt ++; // cnt no tiene “?”
}

j = cheque (cnt); // primer chequeo del primer l2 de ambas cadenas

si (j == 1)
ans ++; // mismo entonces inc ans

int k = 0; // es el primer elemento que necesito eliminar para mover // mi ventana más

for (i = l2; i {

if (f [k]! = ‘?’)
{
j = (f [k] – ‘0’-48); a [j] -;
}
más
if (f [k] == ‘?’)
{cnt–;} // nuevamente haciendo hash del nuevo elemento y // eliminando el primer elemento

k ++;

if (f [i]! = ‘?’)
{
j = (f [i] – ‘0’-48);
a [j] ++;
}

if (f [i] == ‘?’)
{
cnt ++;
}

j = cheque (cnt); /// en cada paso necesito verificar

si (j == 1)
ans ++;
}

printf (“% d \ n”, ans); // mi respuesta final 🙂

devuelve 0;
}

More Interesting

¿Es válido este intento recursivo de bubbleort o se puede optimizar?

¿Es adecuado usar un algoritmo de hash perceptual para desarrollar un motor de búsqueda de imágenes?

Según Knuth, un algoritmo puede tener cero o más entradas. ¿Alguien puede darme un ejemplo de un algoritmo sin entrada?

¿Qué estructura de datos debo usar si estoy diseñando un algoritmo que clasifica las páginas por relevancia de acuerdo con la cantidad de veces que se ven?

Cómo determinar si un algoritmo informático es complejo o no

¿Cuál es la complejidad temporal del montón y el tipo de montón?

Cómo resolver un problema de puente colgante utilizando circuitos y dónde una persona puede cruzar el puente a la vez

Cómo maximizar la suma de las diferencias absolutas en los índices correspondientes de dos matrices sobre todas sus permutaciones posibles

¿Qué algoritmo se pregunta en la entrevista de Google?

¿Cómo puedo usar el algoritmo de Baum-Welch para agregar observaciones perdidas?

¿Cómo funciona el algoritmo de adsorción?

¿Cuál es el mejor algoritmo para encontrar la ruta más corta en un gráfico orientado, donde algunos bordes están bloqueados y las teclas están en algún lugar de los nodos?

¿Cuál es la diferencia entre Manhattan y las medidas de distancia euclidiana?

¿Por qué los desarrolladores no se adhieren al algoritmo de prueba de trabajo de Bitcoin cuando desarrollan nuevas monedas?

¿Cuáles son los mejores libros para algoritmos y estructuras de datos en C?