Leetcode 第 117 场周赛 前三题题解

965. 单值二叉树

题目：

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

示例 1：

输入：[1,1,1,1,1,null,1]
输出：true

示例 2：

输入：[2,2,2,5,2]
输出：false

提示：

1. 给定树的节点数范围是 [1, 100]。
2. 每个节点的值都是整数，范围为 [0, 99] 。

思路：

递归遍历判断左右节点是否与根节点相同即可。

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isUnivalTree(TreeNode* root) {
        if(root==NULL)
            return true;
        int val=root->val;
        if(root->right&&root->right->val!=val)
            return false;
        if(root->left&&root->left->val!=val)
            return false;
        return isUnivalTree(root->right)&&isUnivalTree(root->left);
    }
};

 967. 连续差相同的数字

题目：

返回所有长度为 N 且满足其每两个连续位上的数字之间的差的绝对值为 K 的非负整数。

请注意，除了数字 0 本身之外，答案中的每个数字都不能有前导零。例如，01 因为有一个前导零，所以是无效的；但 0 是有效的。

你可以按任何顺序返回答案。

示例 1：

输入：N = 3, K = 7
输出：[181,292,707,818,929]
解释：注意，070 不是一个有效的数字，因为它有前导零。

示例 2：

输入：N = 2, K = 1
输出：[10,12,21,23,32,34,43,45,54,56,65,67,76,78,87,89,98]

提示：

1. 1 <= N <= 9
2. 0 <= K <= 9

思路：

从最高位开始对每一位进行dfs，。一共有两种搜索情况，要麽在前一位的基础上加上k，要麽减去k。

代码如下：
 

class Solution {
public:
    map<long long ,int>ma;
    vector<int>v;
    void dfs (int N,int K,int loc,long long sum,int qian)
    {
        if(loc==N)
        {
            v.push_back(sum);
            return ;
        }
        if(qian+K<=9)
        {
            long long tsum=sum*10+qian+K;
            if(ma[tsum]==0)
            {
                ma[tsum]=1;
                dfs(N,K,loc+1,tsum,qian+K);
            }
        }
        if(qian-K>=0)
        {
            long long tsum=sum*10+qian-K;
            if(ma[tsum]==0)
            {
                ma[tsum]=1;
                dfs(N,K,loc+1,tsum,qian-K);
            }
        }
    }
    vector<int> numsSameConsecDiff(int N, int K) {
        if(N==1)
        {
            for (int i=0;i<=9;i++)
                v.push_back(i);
            return v;
        }
          for (int i=1;i<=9;i++)
           dfs(N,K,1,i,i);
           return v;
    }
};

966. 元音拼写检查器 

题目：

在给定单词列表 wordlist 的情况下，我们希望实现一个拼写检查器，将查询单词转换为正确的单词。

对于给定的查询单词 query，拼写检查器将会处理两类拼写错误：

• 大小写：如果查询匹配单词列表中的某个单词（不区分大小写），则返回的正确单词与单词列表中的大小写相同。
  • 例如：wordlist = ["yellow"], query = "YellOw": correct = "yellow"
  • 例如：wordlist = ["Yellow"], query = "yellow": correct = "Yellow"
  • 例如：wordlist = ["yellow"], query = "yellow": correct = "yellow"
• 元音错误：如果在将查询单词中的元音（‘a’、‘e’、‘i’、‘o’、‘u’）分别替换为任何元音后，能与单词列表中的单词匹配（不区分大小写），则返回的正确单词与单词列表中的匹配项大小写相同。
  • 例如：wordlist = ["YellOw"], query = "yollow": correct = "YellOw"
  • 例如：wordlist = ["YellOw"], query = "yeellow": correct = "" （无匹配项）
  • 例如：wordlist = ["YellOw"], query = "yllw": correct = "" （无匹配项）

此外，拼写检查器还按照以下优先级规则操作：

• 当查询完全匹配单词列表中的某个单词（区分大小写）时，应返回相同的单词。
• 当查询匹配到大小写问题的单词时，您应该返回单词列表中的第一个这样的匹配项。
• 当查询匹配到元音错误的单词时，您应该返回单词列表中的第一个这样的匹配项。
• 如果该查询在单词列表中没有匹配项，则应返回空字符串。

给出一些查询 queries，返回一个单词答案列表 answer，其中 answer[i] 是由查询 query = queries[i] 得到的正确单词。

示例：

输入：wordlist = ["KiTe","kite","hare","Hare"], queries = ["kite","Kite","KiTe","Hare","HARE","Hear","hear","keti","keet","keto"]
输出：["kite","KiTe","KiTe","Hare","hare","","","KiTe","","KiTe"]

提示：

1. 1 <= wordlist.length <= 5000
2. 1 <= queries.length <= 5000
3. 1 <= wordlist[i].length <= 7
4. 1 <= queries[i].length <= 7
5. wordlist 和 queries 中的所有字符串仅由英文字母组成。

思路：

先将wordlist中的单词装到一个map1中，然后将其中的单词转换为小写字母，然后 存到另一个map2中。

之后将worldlist中单词中的元音字符全用*表示，然后存到map3中，map中的value表示的是序号，已经存在map中的单词就不要重复存了。

之后对queries中的单词进行查找，先对其本身进行在map1中查找，如果没有，则转化为小写字母在map2中进行查找，

如果还没有，则转化为map3中字符串的形式在map3中进行查找
。

代码如下：
 

class Solution {
public:
    map<string,int>ma1,ma2,ma3;
    char c[10]="aeiou";
    vector<string> spellchecker(vector<string>& wordlist, vector<string>& queries) {
        vector<string>v;
        int wsize=wordlist.size(),qsize=queries.size();
        for (int i=0;i<wsize;i++)
        {
            string t=wordlist[i];
            if(ma1.find(t)==ma1.end())
                ma1[t]=i;
            for (int j=0;j<t.size();j++)
            {
                if(t[j]>'z'||t[j]<'a')
                    t[j]=t[j]-'A'+'a';
            }
            if(ma2.find(t)==ma2.end())
            {
                ma2[t]=i;
            }
            for (int j=0;j<t.size();j++)
            {
                int flag=0;
                for (int k=0;k<5;k++)
                    if(t[j]==c[k])
                    {
                        flag=1;
                        break;
                    }
                if(flag)
                    t[j]='*';
            }
            if(ma3.find(t)==ma3.end())
                ma3[t]=i;  
        }
        for (int i=0;i<qsize;i++)
        {
            string qq=queries[i];
            if(ma1.find(qq)!=ma1.end())
            {
                v.push_back(qq);
                continue;
            }
            for (int j=0;j<qq.size();j++)
                if(qq[j]>'z'||qq[j]<'a')
                    qq[j]=qq[j]-'A'+'a';
            if(ma2.find(qq)!=ma2.end())
            {
                v.push_back(wordlist[ma2[qq]]);
                continue;
            }
            for (int j=0;j<qq.size();j++)
            {
                int flag=0;
                for (int k=0;k<5;k++)
                    if(qq[j]==c[k])
                    {
                        flag=1;
                        break;
                    }
                if(flag)
                    qq[j]='*';
            }
            if(ma3.find(qq)!=ma3.end())
            {
                v.push_back(wordlist[ma3[qq]]);
                continue;
            }
            v.push_back("");
        }
        return v;
    }
};