[Entrevista LeetCode-Classic 150 perguntas-dia10]

Índice

242. Alofones válidos

 49. Agrupamento de anagramas alfabéticos

 202. Número feliz

 219. Existem elementos repetidos Ⅱ

 383.Carta de resgate

 205. Cordas isomórficas

290. Regras de palavras 

---

 

242. Alofones válidos

Significado da pergunta:

Dadas duas strings  s e  t , escreva uma função para determinar  t se é  s um anagrama de.

Nota: Se  cada caractere em s e  t aparecer o mesmo número de vezes, então  s e  são t considerados anagramas um do outro.

【Amostra de entrada】

s="anagrama",t="nagaram"

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

É relativamente simples: defina um array para registrar o número de ocorrências de letras em duas strings.

O array alphaNum é inicializado em 0, uma string é responsável por seu ++ e um alinhamento--

Se for um anagrama, o valor final de alphaNum definitivamente ainda será 0

class Solution {
    public boolean isAnagram(String s, String t) {
        //s和t都是小写字母,每个字符出现次数相同，当两个字符长度不一样时也不行
        if(s.length() != t.length()){
            return false;
        }
        int[] alphaNum = new int[26];
        for(int i=0;i<s.length();++i){
            ++alphaNum[s.charAt(i) - 'a'];
        }
        for(int i = 0;i<t.length();++i){
            --alphaNum[t.charAt(i) - 'a'];
            if(alphaNum[t.charAt(i) - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

Tempo: bater 82,24%

Memória: derrotada por 71,71%

 49. Agrupamento de anagramas alfabéticos

Significado da pergunta:

Você recebe uma série de strings e é solicitado a  combinar os anagramas  . A lista de resultados pode ser retornada em qualquer ordem.

Um anagrama  é uma nova palavra obtida reorganizando todas as letras da palavra fonte.

【Amostra de entrada】

strs=["comer","chá","bronzeado","comeu","nat","morcego"]

[Amostra de saída][["eat","tea","ate"],["tan","nat"],["bat"]]

Ideias para resolução de problemas:

Classificação + hash
: obtenha uma string str e classifique-a: por exemplo, "eat" é "aet" após a classificação e salve aet como uma chave no mapa
usando map.getOrDefault(key, new Array<>()) ;
Se esta chave existir no mapa, será retornado o valor correspondente à chave (lista nesta questão).Se não existir tal chave, prova que é a primeira vez que é encontrada, e uma nova lista será criada .

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //方法一：排序+哈希
        Map<String,List<String>> map = new HashMap<String,List<String>>();
        for(String str: strs){
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key,new ArrayList<String>());
            list.add(str);
            map.put(key,list);
        }
        return new ArrayList<List<String>>(map.values());//把map转成对应格式
    }
}

Tempo: bater 99,24%

Memória: derrotada por 40,02%

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //方法二：计数+哈希
        /**
        拿到一个字符串str，按上一题的思路统计出现的次数和字母作为key：如eat为a1e1t1
        用计数统计来替换掉数组排序
        之后是一样的操作
        使用map.getOrDefault(key,new Array<>());
        如果map中存在此key，会将key对应的value(本题是list)返回了，如果没有此key，证明是第一次遇到，new一个list
         */
        Map<String,List<String>> map = new HashMap<String,List<String>>();
        for(String str: strs){
            int[] count = new int[26];
            for(int i=0;i<str.length();++i){
                ++count[str.charAt(i)-'a'];
            }
            //合成key
            StringBuffer key = new StringBuffer();
            for(int i=0;i<26;++i){
                if(count[i]!=0){
                    key.append((char)(i+'a'));//字母
                    key.append(count[i]);//次数
                }
            }
            String strKey = key.toString();
            List<String> list = map.getOrDefault(strKey,new ArrayList<String>());
            list.add(str);
            map.put(strKey,list);
        }
        return new ArrayList<List<String>>(map.values());//把map转成对应格式
    }
}

 202. Número feliz

Significado da pergunta:

Escreva um algoritmo para determinar  n se um número é um número feliz.

"Número Feliz"  é definido como:

• Para um número inteiro positivo, cada vez que o número é substituído pela soma dos quadrados dos seus dígitos em cada posição.
• Em seguida, repita esse processo até que o número chegue a 1, ou ele pode fazer  um loop infinito  , mas nunca chegar a 1.
• Se  o resultado deste processo for  1, então este número é o número feliz.

Se  n for  um número feliz  , devolva-o  true ; caso contrário, devolva-o  false .

【Amostra de entrada】n=19

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

Coleta de hash

Calcule continuamente a soma dos quadrados de cada dígito de n e armazene o número calculado a cada vez no conjunto. Se for descoberto que o n atualmente calculado já está armazenado no conjunto quando n não é igual a 1, isso prova que caiu em um loop infinito.

class Solution {
    private int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }

    public boolean isHappy(int n) {
        Set<Integer> seen = new HashSet<>();
        while (n != 1 && !seen.contains(n)) {
            seen.add(n);
            n = getNext(n);
        }
        return n == 1;
    }
}

 Tempo: bater 85,70%

Memória: derrotada por 81,73%

 219. Existem elementos repetidos Ⅱ

Significado da pergunta:

Dado um array inteiro  nums e um inteiro  k , determine se existem duas  somas de índice diferentes  no array  , satisfatórias   e   . Se presente, retorne   ; caso contrário, retorne   . i jnums[i] == nums[j]abs(i - j) <= ktruefalse

[Exemplo de entrada] nums=[1,2,3,1],k=3

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

nums[i] serve como chave e i serve como valor. Quando nums[j] == nums[i] for encontrado, calcule a diferença entre i e j. Se não atender aos requisitos de k, modifique o valor de nums [i] para j, porque ao percorrer o array, o ponteiro continua retrocedendo.

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        int temp;
        for(int i=0;i<nums.length;++i){
            temp = nums[i];
            if(map.containsKey(temp) && (i - map.get(temp) <=k)){
               return true;
            }
            map.put(temp,i);
        }
        return false;
    }
}

Tempo: bater 85,19%

Memória: derrotada por 47,36%

 383.Carta de resgate

Significado da pergunta:

Dadas duas strings: ransomNote e  magazine , determine  ransomNote se elas podem  magazine ser compostas pelos caracteres internos.

Retorne se possível  true ; caso contrário, retorne  false .

magazine Cada caractere em só pode  ransomNote ser usado uma vez em .

dica:

• 1 <= ransomNote.length, magazine.length <= 105
• ransomNote e  magazine consiste em letras minúsculas em inglês

[Exemplo de entrada] ransomNote="a", magazine = "b"

[Amostra de saída] falso

Ideias para resolução de problemas:

Contar diretamente o número de vezes que cada caractere é usado na revista. Pode ser maior ou igual ao número de vezes que cada caractere é usado no randomNote?

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(magazine.length() < ransomNote.length()){
            return false;
        }
        int[] num = new int[26];
        for(int i=0;i<magazine.length();++i){
            ++num[magazine.charAt(i) - 'a'];
        }
        for(int i=0;i<ransomNote.length();++i){
            --num[ransomNote.charAt(i) - 'a'];
            if(num[ransomNote.charAt(i) - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

Tempo: bater 99,33%

Memória: bate 98,96%

 205. Cordas isomórficas

Significado da pergunta:

Dadas duas strings  s e  t , determine se elas são isomórficas.

Se  s os caracteres puderem ser substituídos de acordo com um determinado relacionamento de mapeamento  t , então as duas strings serão isomórficas.

Cada ocorrência de um caractere deve ser mapeada para outro caractere sem alterar a ordem dos caracteres. Personagens diferentes não podem ser mapeados para o mesmo personagem, o mesmo personagem só pode ser mapeado para o mesmo personagem e os personagens podem ser mapeados para si mesmos.

dica:

• 1 <= s.length <= 5 * 104
• t.length == s.length
• s e  t consiste em quaisquer caracteres ASCII válidos

[Exemplo de entrada] s="egg",t="add"

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

s.charAt(i) é a chave e t.charAt(i) é o valor, que deve ser consistente.

class Solution {
    public boolean isIsomorphic(String s, String t) {
        if(s==null){
            return true;
        }
        Map<Character,Character> map = new HashMap<Character,Character>();
        for(int i=0;i<s.length();++i){
            char key = s.charAt(i);
            if(!map.containsKey(key)){
                //如果这个key和value都不存在的话，那就直接添加key，value
                //key不存在，但是已经有value了，也不行
                if(map.containsValue(t.charAt(i))){
                    return false;
                }
                map.put(key,t.charAt(i));
            }else{
                if(t.charAt(i) != map.get(key)){
                    return false;
                }
            }
        }
        return true;
    }
}

Tempo: bater 58,80%

Memória: derrotada por 76,72%

290. Regras de palavras 

Significado da pergunta:

Dado um padrão  pattern e uma string  s , determine  s se ela segue o mesmo padrão.

Seguir  aqui  refere-se a uma correspondência completa. Por exemplo,  há uma conexão bidirecional entre pattern cada letra e cada palavra não vazia na string  .s 

dica:

• 1 <= pattern.length <= 300
• pattern Contém apenas letras minúsculas em inglês
• 1 <= s.length <= 3000
• s Contém apenas letras minúsculas do inglês e ' '
• s Não contém  pares de espaços iniciais ou finais
• s Cada palavra é  separada por um único espaço 

[Exemplo de entrada] pattern="abba", s="cachorro gato gato cachorro"

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

Semelhante a 205. String isomórfica, exceto que o valor muda de Caractere para String.

class Solution {
    public boolean wordPattern(String pattern, String s) {
        if(s == null){
            return true;
        }
        Map<Character,String> map = new HashMap<Character,String>();
        String[] str = s.split(" ");//根据空格提取单词
        if(pattern.length() != str.length){
            return false;
        }
        for(int i=0;i<pattern.length();++i){
            char key = pattern.charAt(i);
            if(map.containsKey(key) && !(str[i].equals(map.get(key)))){
                return false;
            }
            if(!map.containsKey(key) && map.containsValue(str[i])){
                return false;
            }
            map.put(key,str[i]);
        }
        return true;
    }
}

Tempo: bater 55,43%

Memória: derrotada por 61,55%