2022-8-27 每日一题-层序遍历+标记+剑指offer-字典树+dfs

662. 二叉树最大宽度

难度中等409收藏分享切换为英文接收动态反馈

给你一棵二叉树的根节点 root ，返回树的 最大宽度 。

树的 最大宽度 是所有层中最大的 宽度 。

每一层的 宽度 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 null 节点，这些 null 节点也计入长度。

题目数据保证答案将会在  32 位 带符号整数范围内。

/**
 * 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 widthOfBinaryTree(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        root.val=1;
        q.offer(root);
        int ans=0;
        while (!q.isEmpty()){
            int size=q.size();
            int l=-1;
            int r=-1;
            for (int i=0;i<size;i++){
                TreeNode node=q.poll();
                if (i==0) l=node.val;
                if (i==size-1) r=node.val;
                if (node.left!=null){
                    node.left.val=node.val*2;
                    q.offer(node.left);
                }
                if (node.right!=null){
                    node.right.val=node.val*2+1;
                    q.offer(node.right);
                }
            }
            ans=Math.max(ans,r-l+1);
        }
        return ans;
    }
}

思路：记录当前节点的位置（个数，左子树就是根的两倍，右子树就是根的两倍多一，层序遍历直接看最前面和最后面的宽度。

 

剑指 Offer II 064. 神奇的字典

难度中等28收藏分享切换为英文接收动态反馈

设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。

实现 MagicDictionary 类：

• MagicDictionary() 初始化对象
• void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同
• bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中 一个 字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 true ；否则，返回 false 。

class MagicDictionary {
    Trie root;
    /** Initialize your data structure here. */
    public MagicDictionary() {
        root=new Trie();
    }
    
    public void buildDict(String[] dictionary) {
        for (String s:dictionary){
            Trie head=root;
            for (int i=0;i<s.length();i++){
                int index=s.charAt(i)-'a';
                if (head.children[index]==null){
                    head.children[index]=new Trie();
                }
                head=head.children[index];
            }
            head.isWord=true;
        }
    }
    
    public boolean search(String searchWord) {
        return dfs(searchWord,root,0,false);
    }

    public boolean dfs(String word,Trie root,int index,boolean modified){
        if (index==word.length()) return root.isWord&&modified;
        int idx=word.charAt(index)-'a';
        if (root.children[idx]!=null){
            if (dfs(word,root.children[idx],index+1,modified)){
                return true;
            }
        }
        if (!modified){
            for (int i=0;i<26;i++){
                if (i!=idx&&root.children[i]!=null){
                    if (dfs(word,root.children[i],index+1,true)){
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

class Trie{
    boolean isWord;
    Trie[] children;
    Trie(){
        isWord=false;
        children=new Trie[26];
    }
}

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * MagicDictionary obj = new MagicDictionary();
 * obj.buildDict(dictionary);
 * boolean param_2 = obj.search(searchWord);
 */

思路：字典树记录单词，dfs搜索是否可行。