算法-----字典树

1.字典树简介

（1）用空间换时间的一种典型，如其名，字典，并暴力搜索查找，而是利用前缀去查找，这里的树是一颗拥有最大孩子数目的树。
（2）可以用在基础数据结构上自己加上一些需要的数据，比如以当前结点结尾的word值，以当前结点结尾的前缀数目，以当前结点结尾的字符长度，以当前结点结尾的word的数目（即words中该word重复的数目。）

基本数据结构

Trie[] children=new Trie[27]; //该结点的孩子
String word=""; //以当前结点结尾的word的值
boolean end=false; //当前结点是一个word的结尾吗？
int prCount=1; //以该结点结尾的前缀的数目
int lastCount=0; //以该结点结尾的words数目

package com.company;

public class Trie {
    Trie[] children=new Trie[27];  //该结点的孩子
    String word="";     //以当前结点结尾的word的值
    boolean end=false;  //当前结点是一个word的结尾吗？
    int prCount=1;      //以该结点结尾的前缀的数目
    int lastCount=0;    //以该结点结尾的words数目
    public Trie(){
        for(int i=0;i<children.length;i++){
            children[i]=null;
        }
    }

向结点root为根的树中插入word单词

 public void Insert(String word){
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null){
                root.children[ch-'a']=new Trie();
            }
            else{
                root.children[ch-'a'].prCount++;
            }
            root=root.children[ch-'a'];
        }
        root.lastCount++;
        root.word=word;
        root.end=true;
    }

建立以root为根节点的结点含有words的数

  public Trie createTrie(String[] words){
        Trie root=this;
        for(String word:words){
            root.Insert(word);
        }
        return root;
    }

寻找root树中以word为前缀的word的数目

 public int searchPreStr(String word){
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null) {
                return 0;
            }
            else{
                root=root.children[ch-'a'];
            }
        }
        return root.prCount;
    }

寻找root树中是否存在word单词

 public boolean searchWord(String word){
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null) {
                return false;
            }
            else{
                root=root.children[ch-'a'];
            }
        }
        if(root.word.equals(word)){
            return true;
        }
        else{
            return false;
        }
    }

寻找root树中word单词的数目

    public int searchWordCount(String word){
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null) {
                return 0;
            }
            else{
                root=root.children[ch-'a'];
            }
        }
        if(root.word.equals(word)){
            return root.lastCount;
        }
        else{
            return 0;
        }
    }
}

2.简单应用：

package com.company;

public class Main {
    public static void main(String[] args) {
        Trie root=new Trie();
        String[] words=new String[7];
        //cat，cash，app，apple，apply，ok
        words[0]=new String("cat");
        words[1]=new String("cash");
        words[2]=new String("app");
        words[3]=new String("apple");
        words[4]=new String("apply");
        words[5]=new String("ok");
        words[6]=new String("apply");
        root.createTrie(words);
        System.out.println("cash is appeal? "+root.searchWord("cash"));
        System.out.println("ap 前缀 appeal times："+root.searchPreStr("ap"));
        System.out.println("apply appeal times："+root.searchWordCount("apply"));
    }
}

3.力扣刷题

（1）720. 词典中最长的单词

给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。

若无答案，则返回空字符串。

敲黑板：这里就不是简简单单的直接遍历什么的了，需要根据题目来，基础建立字典树都不变，但是遍历这里需要注意，题目中明确了我最终获得的这个必须是其他的word加1个得到的，也就是说我这一路走过来，必须经过的都是别人的end == true，所以一旦是false那就是错的！！！

class Solution {

    public String longestWord(String[] words) {
        Trie root=new Trie();
        root.createTrie(words);
        dfs(root,0);
        return ans;
    }
    class Trie{
        public boolean end=false;
        public String word="";
        public Trie[] children=new Trie[26];
        public int preCount=1;
        public int lastCount=0;

        public Trie(){
            for(int i=0;i<children.length;i++){
                children[i]=null;
            }
        }

        public void Insert(String word){
            Trie root=this;
            for(char ch:word.toCharArray()){
                if(root.children[ch-'a']==null){
                    root.children[ch-'a']=new Trie();
                }
                else{
                    root.children[ch-'a'].preCount++;
                }
                root=root.children[ch-'a'];
            }
            root.lastCount++;
            root.word=word;
            root.end=true;
        }

        public Trie createTrie(String[] words){
            Trie root=this;
            for(String word:words){
                root.Insert(word);
            }
            return root;
        }
    }

    public int maxLength=0;
    public String ans="";
    
    public void dfs(Trie root,int depth){
        if(depth>0 && !root.end){
            return ;
        }
        if(depth>maxLength){
            maxLength=depth;
            ans=root.word;
        }
        for(Trie child:root.children){
            if(child!=null){
                dfs(child,depth+1);
            }
        }
    }
}

（2）421. 数组中两个数的最大异或值

给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，
其中 0 ≤ i ≤ j < n 。

进阶：你可以在 O(n) 的时间解决这个问题吗？

示例 1：
输入：nums = [3,10,5,25,2,8]
输出：28
解释：最大运算结果是 5 XOR 25 = 28.

class Solution {

    class Trie{
    public Trie[] children=new Trie[2];
    public int num;
    boolean end=false;
    public Trie(){
        for(int i=0;i<children.length;i++){
            children[i]=null;
        }
    }

    public void insert(int num){
        Trie root=this;
        for(int i=30;i>=0;i--){
            int index=(num>>i)&1;
            if(root.children[index]==null){
                root.children[index]=new Trie();
            }
            root=root.children[index];
        }
        root.num=num;
        root.end=true;
    }

    public int findMax(int num){
        int ans=0;
        Trie root=this;
        for(int i=30;i>=0;i--){
            int index=(num>>i)&1;
            index^=1;
            if(root.children[index]!=null){
                ans|=1<<i;
                root=root.children[index];
            }
            else{
                index^=1;
                root=root.children[index];
            }
        }
        return ans;
    }
  }

    public int findMaximumXOR(int[] nums) {
        int max=0;
        Trie root=new Trie();
        for(int num:nums){
            root.insert(num);
            max=Math.max(max,root.findMax(num));
        }
        return max;
    }
}

（3）208. 实现 Trie (前缀树)

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。
boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

class Trie {
    boolean end;
    String word;
    Trie[] children=new Trie[26];
    /** Initialize your data structure here. */
    public Trie() {
        end=false;
        word="";
    }
    
    /** Inserts a word into the trie. */
    public void insert(String word) {
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null){
                root.children[ch-'a']=new Trie();
            }
            root=root.children[ch-'a'];
        }
        root.end=true;
        root.word=word;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        Trie root=this;
        for(char ch:word.toCharArray()){
            if(root.children[ch-'a']==null){
                return false;
            }
            root=root.children[ch-'a'];
        }
        if(root.word.equals(word)){
            return true;
        }
        else{
            return false;
        }
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        Trie root=this;
        for(char ch:prefix.toCharArray()){
            if(root.children[ch-'a']==null){
                return false;
            }
            root=root.children[ch-'a'];
        }
        return true;
    }
}

/**
 * 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);
 */

（4）1638. 统计只差一个字符的子串数目

给你两个字符串 s 和 t ，请你找出 s 中的非空子串的数目，这些子串满足替换 一个不同字符 以后，是 t 串的子串。换言之，请你找到 s 和 t 串中 恰好 只有一个字符不同的子字符串对的数目。
比方说， "computer" 和 "computation" 加粗部分只有一个字符不同： 'e'/'a' ，所以这一对子字符串会给答案加 1 。

请你返回满足上述条件的不同子字符串对数目。

一个 子字符串 是一个字符串中连续的字符。

示例 1：

输入：s = "aba", t = "baba"
输出：6
解释：以下为只相差 1 个字符的 s 和 t 串的子字符串对：
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
加粗部分分别表示 s 和 t 串选出来的子字符串。

class Solution {
    class Trie{
        Trie[] children=new Trie[26];
        int endCount=0;
        public Trie(){}
        public void Insert(String word){
            Trie root=this;
            for(char ch:word.toCharArray()){
                if(root.children[ch-'a']==null){
                    root.children[ch-'a']=new Trie();
                }
                root=root.children[ch-'a'];
            }
            root.endCount++;
        }

        public int compire(String word){
            Trie root=this;
            for(char ch:word.toCharArray()){
                if(root.children[ch-'a']==null){
                    return 0;
                }
                root=root.children[ch-'a'];
            }
            return root.endCount;
        }
    }

    public int countSubstrings(String s, String t) {
        if(s.length()>t.length()){
            String temp=new String(s);
            s=new String(t);
            t=new String(temp);
        }
        Trie root=new Trie();
        for(int i=0;i<t.length();i++){
            for(int j=i+1;j<=t.length();j++){
                root.Insert(t.substring(i,j));
            }
        }
        int count=0;
        for(int i=0;i<s.length();i++){
            for(int j=i+1;j<=s.length();j++){
                String sub=s.substring(i,j);
                for(int k=0;k<sub.length();k++){
                    char[] subArray=sub.toCharArray();
                    for(char changeCh='a';changeCh<='z';changeCh++){
                        if(sub.charAt(k)!=changeCh){
                            subArray[k]=changeCh;
                            count+=root.compire(String.copyValueOf(subArray));
                        }
                    }
                }
            }
        }
        return count;
    }
}

法二：

class Solution {
    public int countSubstrings(String s, String t) {
        int count=0;
        for(int i=0;i<s.length();i++){
            for(int j=i+1;j<=s.length();j++){
                String sstr=s.substring(i,j);
                for(int k=0;k<t.length()-sstr.length()+1;k++){
                    String tstr=t.substring(k,k+sstr.length());
                    count+=match(sstr,tstr);
                }
            }
        }
        return count;
    }

    public int match(String s,String t){
        int dif=0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)!=t.charAt(i)){
                dif++;
            }
            if(dif>1){
                return 0;
            }
        }
        if(dif==1){
            return 1;
        }
        else{
            return 0;
        }
    }
}