LeetCode 820. 单词的压缩编码 (Java版; Meidum)

welcome to my blog

LeetCode 820. 单词的压缩编码 (Java版; Meidum)

题目描述

给定一个单词列表，我们将这个列表编码成一个索引字符串 S 与一个索引列表 A。

例如，如果这个列表是 ["time", "me", "bell"]，我们就可以将其表示为 S = "time#bell#" 和 indexes = [0, 2, 5]。

对于每一个索引，我们可以通过从字符串 S 中索引的位置开始读取字符串，直到 "#" 结束，来恢复我们之前的单词列表。

那么成功对给定单词列表进行编码的最小字符串长度是多少呢？

 

示例：

输入: words = ["time", "me", "bell"]
输出: 10
说明: S = "time#bell#" ， indexes = [0, 2, 5] 。
 

提示：

1 <= words.length <= 2000
1 <= words[i].length <= 7
每个单词都是小写字母 。

第一次做; 核心: 1)前缀树; 使用哈希表记录邻居, 方便知道当前节点是否有邻居, 通过isEmpty()判断; 使用数组记录邻居就不方便判断是否有邻居了

class Solution {
    public int minimumLengthEncoding(String[] words) {
        HashSet<String> set = new HashSet<>(Arrays.asList(words));
        Trie trie = new Trie();
        for(String s : set){
            trie.add(s);
        }
        return trie.getDepthSum();
    }
    class Trie{
        Node root;
        HashSet<Node> set;
        Trie(){
            root = new Node();
            //装叶子节点; 但是有些叶子节点可能之后就不是叶子节点了, 要小心
            set = new HashSet<>();
        }

        void add(String str){
            Node cur = root;
            for(int i=str.length()-1; i>=0; i--){
                char ch = str.charAt(i);
                // int index = ch - 'a';
                if(!cur.next.containsKey(ch)){
                    cur.next.put(ch, new Node());
                }
                cur = cur.next.get(ch);
            }
            cur.depth = str.length()+1;//算上#占用的一个深度
            set.add(cur);
        }

        int getDepthSum(){
            int res = 0;
            for(Node node : set){
                if(node.next.isEmpty()){
                    res += node.depth;
                }
            }
            return res;
        }
    }

    class Node{
        // Node[] nexts;
        HashMap<Character, Node> next;
        int depth;
        Node(){
            // nexts = new Node[26];
            next = new HashMap<>(); //用哈希表的好处是方便直到当前字符有没有下一个字符, 根据isEmpty()判断, 用数组的话就不行了
        }
    }
}

第一次做; 核心: 1)使用set记录每个单词, 然后针对每一个单词, 考虑其子串[i,n-1], 将该子串从set中删除, i>=1, 因为这些子串都是当前单词的后缀 2) HashSet可以使用forEach, HashMap不行 3)Arrays.asList(T… a), 返回值类型是List 3)将所有单词放入set, 可以先过滤掉重复出现的单词

class Solution {
    public int minimumLengthEncoding(String[] words) {
        Set<String> set = new HashSet(Arrays.asList(words));
        for(String word : words){
            for(int i=1; i<word.length(); i++){
                set.remove(word.substring(i));
            }
        }
        int res=0;
        for(String s : set){
            res += s.length()+1;
        }
        return res;
    }
}

LeetCode优秀题解 JDK8新特性, stream()

 public int minimumLengthEncoding(String[] words) {
        Node trie = new Node();
        Set<Node> nodes = new HashSet<>();
        for (String w : words) {
            Node node = trie;
            for (int i = w.length() - 1; i >= 0; i--)
                node = node.add(w.charAt(i));
            node.depth = w.length() + 1;
            nodes.add(node);
        }
        return nodes.stream().filter(n -> n.leaf).mapToInt(n -> n.depth).sum();
    }

    class Node {
        final Node[] next = new Node[26];
        boolean leaf = true;
        int depth;

        Node add(char c) {
            if (next[c - 'a'] == null)
                next[c - 'a'] = new Node();
            leaf = false;
            return next[c - 'a'];
        }
    }

class Solution {
    public int minimumLengthEncoding(String[] words) {
        TrieNode root = new TrieNode();
        List<TrieNode> leaves = new  ArrayList<TrieNode>();
        for (String w : new HashSet<>(Arrays.asList(words))) {
            TrieNode cur = root;
            for (int i = w.length() - 1; i >= 0; --i) {
                char j = w.charAt(i);
                if (!cur.next.containsKey(j)) cur.next.put(j, new TrieNode());
                cur = cur.next.get(j);
            }
            cur.depth = w.length() + 1;
            leaves.add(cur);
        }
        int res = 0;
        for (TrieNode leaf : leaves) if (leaf.next.isEmpty()) res += leaf.depth;
        return res;
    }
}

class TrieNode {
    HashMap<Character, TrieNode> next = new HashMap<>();
    int depth;
}