Let Code Day 38 à partir de zéro "208. Implémenter Trie (Prefix Tree)"

Aperçu

Il semble que des tests de codage soient menés à l'étranger lors d'entretiens d'ingénieurs, et dans de nombreux cas, l'essentiel est d'implémenter des fonctions et des classes spécifiques en fonction du thème.

En guise de contre-mesure, il semble qu'un site appelé Let Code prendra des mesures.

Un site qui forme une puissance algorithmique capable de résister aux tests de codage dont on parle très tôt.

Je pense qu'il vaut mieux avoir la puissance de l'algorithme d'un être humain, donc je vais résoudre le problème de manière irrégulière et écrire la méthode que j'ai pensé à ce moment-là sous forme de mémo.

Leetcode

Table de codes Leet commençant à zéro

Dernière fois Leet Code Day 37 "105. Construire un arbre binaire à partir de précommande et de traversée en ordre"

En ce moment, je résous le support des 100 questions les plus appréciées Facile a été résolu, donc si vous êtes intéressé, veuillez vous rendre à la table.

Twitter Je le fais.

problème

208. Implement Trie (Prefix Tree) Le niveau de difficulté est moyen. Extrait des 100 questions les plus appréciées.

Le problème est que vous devez implémenter les fonctions d'insertion, de recherche et de démarrage avec une classe appelée Trie.

De plus, comme chaque comportement,

Trie trie = new Trie();

trie.insert("apple"); trie.search("apple"); // returns true trie.search("app"); // returns false trie.startsWith("app"); // returns true trie.insert("app");
trie.search("app"); // returns true

Ça ressemble à ça.

Solution

Fondamentalement, tous les arguments sont vérifiés une fois avec l'instruction for, et s'il n'existe pas dans l'élément initialement conservé, «False» est renvoyé ou «{}» est remplacé.

class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.element = {}
        

    def insert(self, word: str) -> None:
        """
        Inserts a word into the trie.
        """
        inserted = self.element
        for tmp in word:
            if tmp not in inserted:
                inserted[tmp] = {}
            inserted = inserted[tmp]
        inserted["-"] = True
        

    def search(self, word: str) -> bool:
        """
        Returns if the word is in the trie.
        """
        
        searched = self.element
        for tmp in word:
            if tmp not in searched:
                return False
            searched = searched[tmp]
        return "-" in searched
        

    def startsWith(self, prefix: str) -> bool:
        """
        Returns if there is any word in the trie that starts with the given prefix.
        """
        started = self.element
        for tmp in prefix:
            if tmp not in started:
                return False
            started = started[tmp]
        return True
        


# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

# Runtime: 128 ms, faster than 94.63% of Python3 online submissions for Implement Trie (Prefix Tree).
# Memory Usage: 27.3 MB, less than 66.67% of Python3 online submissions for Implement Trie (Prefix Tree).

C'était plus rapide que ce à quoi je m'attendais et j'ai pu le mettre en œuvre correctement.

En ce qui concerne la discussion, l'autre réponse majeure a été

from collections import defaultdict


class TrieNode(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.nodes = defaultdict(TrieNode)  # Easy to insert new node.
        self.isword = False  # True for the end of the trie.


class Trie(object):
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        """
        Inserts a word into the trie.
        :type word: str
        :rtype: void
        """
        curr = self.root
        for char in word:
            curr = curr.nodes[char]
        curr.isword = True

    def search(self, word):
        """
        Returns if the word is in the trie.
        :type word: str
        :rtype: bool
        """
        curr = self.root
        for char in word:
            if char not in curr.nodes:
                return False
            curr = curr.nodes[char]
        return curr.isword

    def startsWith(self, prefix):
        """
        Returns if there is any word in the trie
        that starts with the given prefix.
        :type prefix: str
        :rtype: bool
        """
        curr = self.root
        for char in prefix:
            if char not in curr.nodes:
                return False
            curr = curr.nodes[char]
        return True
# Runtime: 192 ms, faster than 57.66% of Python3 online submissions for Implement Trie (Prefix Tree).
# Memory Usage: 32.5 MB, less than 7.41% of Python3 online submissions for Implement Trie (Prefix Tree).

C'était comme ça. Vous avez créé une classe séparée appelée TrieNode et utilisé quelque chose appelé defaultdict. Cependant, en ce qui concerne cette fois, je pense que la première réponse est plus facile à comprendre et plus rapide, donc je pense que c'est mieux.

Cette fois, cela ressemble à ceci, merci pour votre travail acharné.