【LeetCode】809.情感丰富的文字

Schanappi

已于 2022-11-26 11:54:57 修改

阅读量71

点赞数

分类专栏： LeetCode刷题

于 2022-11-25 11:07:12 首次发布

本文链接：https://blog.csdn.net/weixin_43894455/article/details/128033423

版权

word

LeetCode刷题专栏收录该内容

218 篇文章 6 订阅

订阅专栏

题目描述

有时候人们会用重复写一些字母来表示额外的感受，比如 “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。
输入一组查询单词，输出其中可扩张的单词数量。

示例 1：

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

提示：

0 <= len(S) <= 100。
0 <= len(words) <= 100。
0 <= len(words[i]) <= 100。
S 和所有在 words 中的单词都只由小写字母组成。

方法一：双指针

class Solution {
public:
    int expressiveWords(string s, vector<string>& words) {
        int len1 = s.size();
        int res = 0; // 可扩张的单词数量

        for(auto &word : words){
            // expand函数判断word是否可以扩张
            if(expand(s, word)) res ++;
        }    
        return res;
    }
    bool expand(const string& s,const string& word){
        int i=0, j=0; // 定义双指针
        while(i < s.size() && j < word.size()){
            if(s[i] != word[j]) return false;
            // s[i] == s[j]
            // 记录当前相同的字符，用于比较
            char ch = s[i];
            int cnti = 0; // 记录s中相同字符的个数
            while(i< s.size() && s[i] == ch){
                i++;
                cnti++;
            }
            int cntj = 0; // 记录word中相同字符的个数
            while(j < word.size() && word[j] == ch){
                j++;
                cntj++;
            }
            // s中相同字符的个数比word少，则必不可能扩张
            if(cnti < cntj) return false;
            // s中相同字符的个数少于3，则必不可能扩张
            if(cnti != cntj && cnti<3)  return false;
            //剩下一种情况：cnti >=3 可以扩张
        }
        // 两者都遍历结束，说明可以扩张
        return i == s.size() && j == word.size();
    }
};

心得

一开始不小心看了题解，因此知道这道题要用 双指针 来解决，但是一直没能处理好，只能通过两三种情况，感觉我还需要理清楚每一种情况再动手。
首先介绍一下我的思路，定义两个指针 i 和 j ，分别指向字符串 s 和待匹配字符串 word，依次使用指针遍历 s 和 word 的每个字符，我主要是分成四种情况考虑：

如果 i == s.size() ，说明 s 已经遍历完成；
如果 j == word.size() ，说明word 已经遍历完成，此时还需要考虑 s 剩余的字符串是否和 word [j-1] 相等，如果相等则说明可扩张；
如果 s[i] == word[j]，说明两者当前字符匹配，继续遍历下一个字符；
如果s[i] != word[j]，说明两者当前字符不匹配，那么可能出现了两种情况：
可能出现了可扩张字符，即 oool 和 ol 这种情况，s 遍历到第二个 o，word 遍历到 l，此时计算 o 的重复个数，发现 >= 3，则符合可扩张，继续从 l 开始遍历；
如果重复个数 < 3，则不可扩张，退出循环，考虑下一个 word；
二者完全不匹配，比如 axcd 和 bzie。

目前我的思路能通过 22/34 的测试点，比如下面这个测试点就没办法通过；

输入：
s =“aaabbbaaa”
words =[“a”]
输出：0

感觉我的思路整体不太流畅，还是直接看题解，在末尾存一下我自己写的代码。

方法：双指针
思路：
依次判断给定数组 words 中的每一个字符串是否能扩张成 s。首先设置两个指针 i 和 j 分别指向 s 和 word，开始遍历；
首先需要保证 s[i] == word[j]，否则这两部分不是相同的字母，无法扩张；
随后不断向右移动两个指针，直到移动到与之前不同的字母，或者达到字符串的边界。假设字符串 s 有 cnt_i 个相同的字母，字符串 word 有 cnt_j 个相同的字母，那么需要保证 cnt_i >= cnt_j 。
当 cnt_i == cnt_j 的时候，无需扩张，这样子也是符合要求的；
当 cnt_i > cnt_j 的时候，需要确保 cnt_i >= 3。

当某一个字符串到达边界的时候，我们可以退出上述的遍历过程；当两个字符串都到达边界的时候，说明两个字符串同时遍历完成， word 可以扩张成 s。

我的代码，未通过

class Solution {
public:
    int IsRepeated(string s,char c, int i){
        int cnt = 1;
        while(i<s.size() && s[i] == c){
            cnt ++;
            i ++;
        }
        return cnt;
    }
    int expressiveWords(string s, vector<string>& words) {
        int len1 = s.size();
        int res = 0; // 可扩张的单词数量

        for(auto &word : words){
            int cnt = 1; // 记录扩展字母数量
            int len2 = word.size();
            // 定义双指针，i指向s，j指向word
            int i = 0, j = 0;
            while(1){
                if(i == len1)   break;
                if(j == len2){
                    cnt = IsRepeated(s, s[i-1], i);
                    i += cnt - 1;
                    if(cnt >= 3)    res ++;
                    break;
                }
                if(s[i] == word[j]){
                    i ++;
                    j ++;
                }
                else{ 
                    // s[i] != word[j]
                    // 检查s[i]接下来是不是会至少重复3次
                    if(j == 0)  break;
                    cnt = IsRepeated(s, word[j-1], i);
                    i += cnt - 1;
                    if(cnt >= 3)    continue;
                    // 少于三次，不可扩张
                    else break;
                }
            }
        }
        return res;
    }
};