前缀树的构造+应用

构造前缀树（不同题目，构造的属性不同）

抽象：关键是成员变量的构造

class Trie {

    //成员变量（本层孩子+末节点的标志）
    private Trie[] children;
    private boolean isEnd;

    public Trie() {
        children=new Trie[26];
        isEnd=false;
    }
    
    public void insert(String word) {
        Trie cur=this;
        for(int i=0;i<word.length();i++){
            char c=word.charAt(i);
            int index=c-'a';
            if(cur.children[index]==null){
                cur.children[index]=new Trie();
            }
            cur=cur.children[index];
        }
        cur.isEnd=true;
    }
    
    public boolean search(String word) {
        Trie last=existPrefix(word);
        return last!=null&&last.isEnd==true ? true:false;

    }
    
    public boolean startsWith(String prefix) {
        return existPrefix(prefix)!=null?true:false;
    }

    public Trie existPrefix(String prefix){
        Trie cur=this;
        for(int i=0;i<prefix.length();i++){
            char c=prefix.charAt(i);
            int index=c-'a';
            //中途就有字符不存在，匹配不上了
            if(cur.children[index]==null){
                return null;
            }
            cur=cur.children[index];
        }

        return cur;
    }
}

/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */

单词的压缩编码（前缀树应用）

注意这里的set集合首先充当了第一轮的去重操作，其次借助容器的remove功能进行删除冗余的后缀字符串

class Solution {
    public int minimumLengthEncoding(String[] words) {

        //Arrays.asList(words)将字符串数组转化为list列表的集合
        Set<String> set=new HashSet<>(Arrays.asList(words));

        //开始删除冗余的成员（穷举）
        for(String word:words){
            //原因word字符串中含有所有的后缀，所以不需要重复的后缀
            for(int i=1;i<word.length();i++){
                set.remove(word.substring(i));
            }
        }

        int res=0;
        for(String word:set){
            res=res+word.length()+1;
        }

        return res;

    }
}

解法二：直接使用前缀树，原因前缀树的叶子结点的count=0，代表没有孩子节点，因此将每个节点作为map的键，检查是否是叶子结点，来决定是否需要加入长度计算

路径总和（前缀和思想）

初始化时，前缀和为0的路径已经是一个了

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

//  利用前缀和的思想进行求解
class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        HashMap<Long, Integer> prefix = new HashMap<>();
        prefix.put(0L, 1);
        return dfs(root, prefix, 0, targetSum);
    }


//利用好cur一直记录到当前节点至根节点之间的路径之和（一直更新hashmap数组，注意一定要按照路径添加）
    public int dfs(TreeNode root, Map<Long, Integer> prefix, long curr, int targetSum) {
        if(root==null){
            return 0;
        }

        int ret;//统计以本节点为末尾节点的targetsum满足的路径数量

        curr=curr+root.val;

        ret=prefix.getOrDefault(curr-targetSum,0);//判断有没有那样的前缀和（寻找头节点个数）
        
        prefix.put(curr,prefix.getOrDefault(curr,0)+1);//将包含当前节点的前缀和加入map中

        //继续自顶向下递归：寻找左右节点的情况
        ret=ret+dfs(root.left,prefix,curr,targetSum);
        ret=ret+dfs(root.right,prefix,curr,targetSum);

        //为了左子树的前缀和不影响右子树的判断，将当前的节点的前缀和减一(相当于一个回溯过程)
        prefix.put(curr,prefix.getOrDefault(curr,0)-1);

        return ret;



    }
}