wy的leetcode刷题记录_Day52

wy的leetcode刷题记录_Day52

声明

本文章的所有题目信息都来源于leetcode
如有侵权请联系我删掉!
时间：2022-11-25

前言

补

809. 情感丰富的文字

今天的每日一题是：809. 情感丰富的文字

题目介绍

有时候人们会用重复写一些字母来表示额外的感受，比如 “hello” -> “heeellooo”, “hi” -> “hiii”。我们将相邻字母都相同的一串字符定义为相同字母组，例如：“h”, “eee”, “ll”, “ooo”。

对于一个给定的字符串 S ，如果另一个单词能够通过将一些字母组扩张从而使其和 S 相同，我们将这个单词定义为可扩张的（stretchy）。扩张操作定义如下：选择一个字母组（包含字母 c ），然后往其中添加相同的字母 c 使其长度达到 3 或以上。

例如，以 “hello” 为例，我们可以对字母组 “o” 扩张得到 “hellooo”，但是无法以同样的方法得到 “helloo” 因为字母组 “oo” 长度小于 3。此外，我们可以进行另一种扩张 “ll” -> “lllll” 以获得 “helllllooo”。如果 s = “helllllooo”，那么查询词 “hello” 是可扩张的，因为可以对它执行这两种扩张操作使得 query = “hello” -> “hellooo” -> “helllllooo” = s。

输入一组查询单词，输出其中可扩张的单词数量。

示例：
输入： s = “heeellooo” words = [“hello”, “hi”, “helo”]
输出：1
解释：
我们能通过扩张 “hello” 的 “e” 和 “o” 来得到 “heeellooo”。 我们不能通过扩张 “helo” 来得到"heeellooo" 因为 “ll” 的长度小于 3 。

思路

比较绕脑的模拟题，根据题意我们将s与words中的word一个一个进行比较找出符合条件的元素。如何寻找符合条件的？我们用双指针法一个指向s的开头，一个指向word的开头，同时遍历，首先我们判断当前俩个指针指向的元素是否连续重复，如果连续重复的话我们需要判断其重复次数，如果word重复次数大于s的重复次数那么也不行，如果s的重复次数小于3并且s的重复次数不与word的重复次数相等也不行。其次，这个时候我们已经保证了当前遍历的元素已经不是上一个连续的重复元素了，这个时候如果俩边指针指向的元素不相等的话那么也不行。

代码

class Solution {
public:
    int expressiveWords(string s, vector<string>& words) {
        int ans=0;
        for(auto word:words)
        {
            if(isStretchy(s,word))
                ans++;
        }
        return ans;
    }
    bool isStretchy(string s,string& t)
    {
        int i=0,j=0;
        int n=s.size();
        int m=t.size();
        while(i<n&&j<m)
        {
            if(s[i]!=t[j])
            {
                return false;
            }
            char ch=s[i];
            int count_s=0;
            while(i<n&&s[i]==ch)
            {
                count_s++;
                i++;
            }
            int count_t=0;
            while(j<m&&t[j]==ch)
            {
                count_t++;
                j++;
            }
            if(count_t>count_s)
                return false;
            
            if(count_s!=count_t&&count_s<3)
                return false;
        }
        return (i==n&&j==m);
    }
};

收获

仔细思考！

501. 二叉搜索树中的众数

501. 二叉搜索树中的众数

题目介绍

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

• 结点左子树中所含节点的值 小于等于 当前节点的值
• 结点右子树中所含节点的值 大于等于 当前节点的值
• 左子树和右子树都是二叉搜索树

示例 1：

输入：root = [1,null,2,2]
输出：[2]

示例 2：
输入：root = [0]
输出：[0]

思路

方法一：暴力搜索DFS：不考虑其为搜索树的情况下，使用dfs遍历所有节点并且将所有节点的出现次数放入一个哈希表中，然后遍历哈希表找出出现最多的次数及其下标。
方法二：考虑到这是一个搜索树，那我们肯定要利用其性质，我们中序遍历这个搜索树得到一个有序的序列，根据这个然后我们判断序列中相邻的俩个元素，来判断其众数个数，这里有个小tips：按照常理来说我们应该遍历俩边树，第一遍寻找众数出现的次数，第二次寻找相应的众数，这里我们用来一个小方法就是，每当我们更新众数出现的次数的时候我们将之前存贮众数的数组清空，再将本次的新众数放入，（更新众数的情况只有出现频频次于之前的出现频次，不包括等于）。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    unordered_map<int,int> hash;
    vector<int> findMode(TreeNode* root) {
        dfs(root);
        vector<int> ans;
        int max1=INT_MIN;
        for(auto temp:hash)
        {
            max1=max(max1,temp.second);
        }
        for(auto temp:hash)
        {
            if(temp.second==max1)
                ans.push_back(temp.first);
        }
        return ans;

    }
    void dfs(TreeNode* node)
    {
        if(!node)
            return;
        if(!hash.count(node->val))
            hash[node->val]=1;
        else
            hash[node->val]++;
        dfs(node->left);
        dfs(node->right);
    }   
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> ans;
    int maxCount=0;
    TreeNode* pre=nullptr;
    int count=0;
    vector<int> findMode(TreeNode* root) {
        find(root);
        return ans;
    }
    void find(TreeNode* node)
    {
        if(!node)
            return;
        find(node->left);


        if(pre==nullptr)//第一个节点的情况
        {
            count=1;
        }
        else if(node->val==pre->val)
        {
            count++;
        }
        else
        {
            count=1;
        }
        pre=node;
        if(count==maxCount)
        {
            ans.push_back(node->val);
        }
        if(count>maxCount)
        {
            ans.clear();
            maxCount=count;
            ans.push_back(node->val);
        }
        find(node->right);
        return;
    }
};

收获

很简单的树题。