Una [categoría de tema]

tabla de picadillo

Dos [dificultad de la pregunta]

Simple

Tres [número de tema]

205. Cuerdas isomorfas

Cuatro [descripción del título]

Dadas dos cadenas s y t, determina si son isomorfas.
Si los caracteres en s se pueden reemplazar de acuerdo con una cierta relación de mapeo para obtener t, entonces las dos cadenas son isomorfas.
Cada aparición de un carácter debe asignarse a otro carácter sin cambiar el orden de los caracteres. No se pueden asignar diferentes caracteres al mismo carácter, el mismo carácter solo se puede asignar al mismo carácter y un carácter se puede asignar a sí mismo.

Cinco [ejemplo de tema]

Ejemplo 1:
- Entrada: s = "huevo", t = "añadir"
- Salida: verdadero
Ejemplo 2:
- Entrada: s = "foo", t = "barra"
- salida: falso
Ejemplo 3:
- Entrada: s = "papel", t = "título"
- Salida: verdadero

Seis [mensaje de tema]

$1 <= s.longitud <= 5 * 10^4$
$t . longitud_____== s . longitud_____$
$s y t constan de cualquier carácter ASCII válido$

Siete [ideas para resolver problemas]

Usando la idea de una tabla hash, debemos asegurarnos de que:
- Para la misma letra, debe asignarse a la misma letra
- Para letras diferentes, no se puede asignar a la misma letra
Entonces construimos dos tablas hash respectivamente para cumplir con los requisitos anteriores
La primera tabla hash se usa para determinar si la misma letra se asigna a la misma letra, y una comparación directa es suficiente.Si la misma letra no se puede asignar a la misma letra, devuelva falso
La segunda tabla hash se usa para determinar si letras diferentes se asignan a la misma letra, y la comparación directa es suficiente.Si se pueden asignar letras diferentes a la misma letra, entonces devuelve falso
Si ninguno de los juicios anteriores devuelve falso en el ciclo, significa que las dos cadenas son cadenas isomorfas, simplemente devuelva verdadero

Ocho 【Frecuencia de tiempo】

Complejidad del tiempo: $O (n)$ , $n$ es la longitud de la cadena entrante, y la longitud de las dos cadenas entrantes es igual
Complejidad espacial: $O (∣Σ∣)$ , $Σ$ es el tamaño del conjunto de caracteres de la cadena entrante

Nueve [implementación de código]

Versión del lenguaje Java

class Solution {
    
    
    public boolean isIsomorphic(String s, String t) {
    
    
        int lenS = s.length();
        int lenT = t.length();
        if(lenS != lenT){
    
    
            return false;
        }
        HashMap<Character, Character> map = new HashMap<>();
        for(int i = 0;i < lenS;i++){
    
    
            if(map.containsKey(s.charAt(i))){
    
    
                if(map.get(s.charAt(i)) != t.charAt(i)){
    
    
                    return false;
                }
            }else{
    
    
                if(map.containsValue(t.charAt(i))){
    
    
                    return false;
                }
                map.put(s.charAt(i), t.charAt(i));
            }
        }
        return true;
    }
}

Versión en lenguaje C

struct HashTable
{
    
    
    char key;
    char val;
    UT_hash_handle hh;
};

bool isIsomorphic(char * s, char * t)
{
    
    
    struct HashTable* mapS = NULL;
    struct HashTable* mapT = NULL;
    int lenS = strlen(s);
    int lenT = strlen(t);
    if(lenS != lenT)
    {
    
    
        return false;
    }
    for(int i = 0;i < lenS;i++)
    {
    
    
        char tempS = s[i];
        char tempT = t[i];
        struct HashTable* valS;
        struct HashTable* valT;
        HASH_FIND(hh, mapS, &tempS, sizeof(char), valT);
        HASH_FIND(hh, mapT, &tempT, sizeof(char), valS);
        if(valT != NULL)
        {
    
    
            if(valT->val != tempT)
            {
    
    
                return false;
            }
        }
        else
        {
    
    
            valT = malloc(sizeof(struct HashTable));
            valT->key = tempS;
            valT->val = tempT;
            HASH_ADD(hh, mapS, key, sizeof(char), valT);
        }
        if(valS != NULL)
        {
    
    
            if(valS->val != tempS)
            {
    
    
                return false;
            }
        }
        else
        {
    
    
            valS = malloc(sizeof(struct HashTable));
            valS->key = tempT;
            valS->val = tempS;
            HASH_ADD(hh, mapT, key, sizeof(char), valS);
        }
    }
    return true;
}

Versión en lenguaje Python

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        lenS = len(s)
        lenT = len(t)
        if lenS != lenT:
            return False
        mapS = {
    
    }
        mapT = {
    
    }
        for tempS, tempT in zip(s, t):
            if (tempS in mapS and mapS[tempS] != tempT) or (tempT in mapT and mapT[tempT] != tempS):
                return False
            mapS[tempS] = tempT
            mapT[tempT] = tempS
        return True

Versión del lenguaje C++

class Solution {
    
    
public:
    bool isIsomorphic(string s, string t) {
    
    
        int lenS = s.size();
        int lenT = t.size();
        if(lenS != lenT){
    
    
            return false;
        }
        unordered_map<char, char> mapS;
        unordered_map<char, char> mapT;
        for(int i = 0;i < lenS;i++){
    
    
            char tempS = s[i];
            char tempT = t[i];
            if((mapS.count(tempS) && mapS[tempS] != tempT) || (mapT.count(tempT) && mapT[tempT] != tempS)){
    
    
                return false;
            }
            mapS[tempS] = tempT;
            mapT[tempT] = tempS;
        }
        return true;
    }
};