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;
    }
};