Leetcode 809. 情感丰富的文字

Leetcode 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 。

提示：

• 1 <= s.length, words.length <= 100
• 1 <= words[i].length <= 100
• s 和所有在 words 中的单词都只由小写字母组成。

我的想法：
一、最开始想的是，搞 defaultdict。
遍历 s， 得出 字符 和 个数 的对应关系。
再遍历 words，遍历 word ，得出 字符 和 个数 的对应关系，拿这个对应关系和 s 的对应关系做比较。

class Solution:
    def expressiveWords(self, s: str, words: List[str]) -> int:
        sdict = defaultdict(int)
        for c in s:
            sdict[c] += 1
        slen = len(s)
        numsum = 0
        for word in words:
            if len(word) > slen:
                continue
            wdict = defaultdict(int)
            for w in word:
                if w in s:
                    wdict[w] += 1
                    flaglist = 1
                else:
                    flaglist = 0
                    break
            if flaglist:
                if len(sdict) == len(wdict):
                    for k, v in wdict.items():
                        if sdict[k] == v:
                            flagstring = 1
                            continue
                        elif sdict[k] >= 3 and v <= sdict[k]:
                            flagstring = 1
                            continue
                        else:
                            flagstring = 0
                            break
                    if flagstring:
                        numsum += 1
                        print(numsum)
        return numsum 

但是失败了，这个测试案例没过去。

“sass”
[“sa”]

说明我这个想法不对。

二、换一种想法，使用数组，双指针。
1.遍历 s，i 指向0，j 指向1。sumnum 作为记录字符出现个数，初始值为1。slist 作为记录 字符 和 字符的对应关系 的数组，比如：[[“h”,1],[“e”,3],[“l”,2],[“o”,1]]

word 也是同样的遍历，这样就可以写一个函数了。

举个例子：
heeeeeellllloooooo
i 指向0，为h；j 指向1，为 e，sumnum = 1，slist = []
因为 h 与 e 不相等，就把i指向的字符和对应的 sumnum 放入 slist 中。然后让 i 指向 j 指的字符，j 向右移一位，sumnum 重置为1。

即：
heeeeeellllloooooo
i 指向1，为e；j 指向2，为 e，sumnum = 1，slist = [[“h”,1]]
因为 e 与 e 相等，j 向右移一位, sumnum += 1。
直到 j 指向 l 的时候。

即：
heeeeeellllloooooo
此时，i 指向1，为e；j 指向7，为 l，sumnum = 6，slist = [[“h”,1]]
因为 e 与 l 不相等，就把i指向的字符和对应的 sumnum 放入 slist 中。然后让 i 指向 j 指的字符，j 向右移一位。sumnum 重置为1。

即：
heeeeeellllloooooo
此时，i 指向7，为l；j 指向8，为 l，sumnum = 1，slist = [[“h”,1],[“e”,6]]

注意到最后还应该将最后一个字符和对应的 sumnum 加入到slist数组中。

3.进行遍历 words 判断：
(1)当 slist 的长度与 wordlist 的长度不同时，那说明这个 word 不是想要的；
(2)长度相同了，使用一个flag作为判断，如果flag为1，说明word为所求；如果为0，说明word不是想要的。

遍历slist,先判断 wordlist[i][0] 和 slist[i][0]是否相等，即判断对应字符是否满足要求（字符相等且顺序一致）。不相等的话 flag = 0，退出循环，进行下一个 word 的判断；

如果 wordlist[i][0] 和 slist[i][0] 相等，再判断 wordlist[i][1] 与 slist[i][1]的关系，即判断字符对应的个数是否满足要求：
当 s 中字符的个数小于 word 中字符的个数时，flag = 0，退出循环，进行下一个 word 的判断；
当 s 中字符的个数大于 word 中字符的个数时，而且 s 中字符的个数小于 3，flag = 0，退出循环，进行下一个 word 的判断；
其他的时候满足条件，进行下一个字符的检查。

当一个word检查完毕且满足要求，所求的个数加一。

class Solution:
    def expressiveWords(self, s: str, words: List[str]) -> int:
        newwords = list()

        def listfun(s):
            slen = len(s)
            i = 0
            j = sumnum = 1
            slist = list()
            while i < slen and j < slen:
                if s[i] != s[j]:
                    slist.append([s[i], sumnum])
                    sumnum = 1
                    i = j
                    j += 1
                else:
                    j += 1
                    sumnum +=1
            slist.append([s[-1], sumnum])
            return slist
            
        slist = listfun(s)
        slistlen = len(slist)
        sumnum = 0
        for word in words:
            wordlist = listfun(word)
            if len(wordlist) != slistlen:
                continue
            else:
                flag = 1
                for i in range(slistlen):
                    if wordlist[i][0] == slist[i][0]  :
                        if wordlist[i][1] > slist[i][1]:
                            flag = 0
                            break
                        elif wordlist[i][1] < slist[i][1]:
                            if slist[i][1] < 3:
                                flag = 0
                                break
                    else:
                        flag = 0
                        break
                if flag :
                    sumnum += 1
        return sumnum

看看其他人的题解：
官方 - 双指针
【爪哇缪斯】图解LeetCode
ylb - 遍历计数 + 双指针