【LeetCode每日一题】（字典树详解）677. 键值映射

目录

题目

一、解题思路

二、结果

1.注意点

2.Java代码

总结

---

题目

实现一个 MapSum 类，支持两个方法，insert 和 sum：

MapSum() 初始化 MapSum 对象
void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键 key 已经存在，那么原来的键值对将被替代成新的键值对。
int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。

示例：

输入：
["MapSum", "insert", "sum", "insert", "sum"]
[[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
输出：
[null, null, 3, null, 5]

解释：
MapSum mapSum = new MapSum();
mapSum.insert("apple", 3);  
mapSum.sum("ap");           // return 3 (apple = 3)
mapSum.insert("app", 2);    
mapSum.sum("ap");           // return 5 (apple + app = 3 + 2 = 5)

提示：

1 <= key.length, prefix.length <= 50
key 和 prefix 仅由小写英文字母组成
1 <= val <= 1000
最多调用 50 次 insert 和 sum

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/map-sum-pairs

一、解题思路

1. 根据题目内容解析：
需要插入（插入值得时候如果重复就更新，否则就插入，类似Hash表）
需要求和，这里就是关键，如果只是普通的全字符匹配的，直接hash表搞定，可惜这里是前缀匹配，一看到前缀匹配的，直接就是前缀树（字典树）

2. 根据要求设计结构：
需要子节点集合（或数组 Node nodes）：节点要求是
1 <= key.length, prefix.length <= 50
key 和 prefix 仅由小写英文字母组成
炸一看小写字母，直接使子数组，下标即为字符（将字符安装在路径上），长度26个字母，下标即为字符 - 'a'
需要当前节点的值（int val）：
意思是以当前节点为结尾的KEY，所得到的值Value
》》》 需要求和节点（int sum）：
这个是后序的编码过程中发现，如果求子和放在sum中，是需要遍历所有子节点的，这里的时间复杂度就比较高
就考虑到了一个解决办法，在insert的时候就将所有走过的路径都更新sum值就好啦，只是一条路径的深度遍历即可
》》》 需要父节点（Node father）：
这个是后序的编码过程中发现，在设计求和节点时会在insert中去在路径上重新复制sum，这里重投走一遍也是需要遍历
解决上面的办法：想到了用Stack去存储所有路径上的Node节点，这里就出现了自建栈
再后面考虑下调整为路径创建时可以同步赋值下父节点，这里就变成双通道节点，方便处理路径返回，也不需要自建栈了
3.规划方法
结构中已经有了求和节点，求和时，就等于全路径匹配prefix直接返回最后字符节点的sum即可
结构中有了父节点，在insert时，对于新创建的节点，将父节点赋值，当更新val时，记录变更的大小，直接原路返回更新所有father的sum即可

二、结果

1.注意点

若字符串无效，直接返回

2.Java代码

代码如下（示例）：

class MapSum {

    // 创建字符对应数组
    Node head;

    // 初始化前缀树
    public MapSum() {
        head = new Node();
    }

    /**
     * 插入K-V
     * @param key 所使用的key
     * @param val 所保存得val
     */
    public void insert(String key, int val) {
        // 若字符串无效，直接返回
        if (key == null || key.length() == 0) {
            return;
        }
        // 暂存节点
        Node n = head;
        // 循环到对应字符所在结尾的节点下
        for (char c : key.toCharArray()) {
            int index = c - 'a';
            if (n.nodes[index] == null) {
                n.nodes[index] = new Node();
                n.nodes[index].father = n;
            }
            n = n.nodes[index];
        }
        // 计算需要修改上级的和
        int temp = val - n.val;
        // 复制当前节点值为val
        n.val = val;
        // 加和
        n.sum += temp;
        while (n.father != null) {
            n = n.father;
            n.sum += temp;
        }
    }

    /**
     * 计算前缀和
     * @param prefix 前缀
     * @return 返回当前节点的和
     */
    public int sum(String prefix) {
        // 无效前缀直接返回
        if (prefix == null || prefix.length() == 0) {
            return 0;
        }
        // 临时节点
        Node n = head;
        // 循环道前缀最后字符
        for (char aChar : prefix.toCharArray()) {
            n = n.nodes[aChar - 'a'];
            if (n == null) {
                return 0;
            }
        }
        return n.sum;
    }

    static class Node{
        // 每一个节点上都有node数组，下标对应每个字符
        Node[] nodes = new Node[26];
        // 配合used使用，当used为true时，当前为以当前节点为结尾的字符串为KEY的值VALUE
        int val = 0;
        // 当前节点以及子节点所有和
        int sum = 0;
        // 记录父亲值
        Node father;
    }
}

总结

加油加油