11.25lc每日一题-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 <= 1001 <= words[i].length <= 100s 和所有在 words 中的单词都只由小写字母组成。

思路:n方暴力,一趟n方用结构体存下每个字符转的连续相同字母的区间个数和大小,然后再来一趟n方比较s和每个words,注意题意中是组扩展成组,”oo”可以扩展为”ooo”,只要扩展后的长度>=3就行.

class Solution {
    int book[105] = {0};
    struct node
    {
        char x;
        int use = 1;//若果字符顺序不匹配直接弃用
        int times = 0;//连续相同字符的长度
    }e[105][105];
    int ans=0;
public:
    int expressiveWords(string s, vector<string>& words) {
        char pre = s[0];
        int temp = 1;
        for(int i = 0;i<s.length();i++)//记录下s的字符分布情况
        {
           if(s[i]==pre)
           {
               e[100][temp].x = s[i];
               e[100][temp].times+=1;
               pre = s[i];
           }
           else
           {
               temp++;
               e[100][temp].x = s[i];
               e[100][temp].times++;
               pre = s[i];
           }
        }
        int k = temp;
        //cout<<k<<endl;
        for(int i = 0;i<words.size();i++)//对每一个words也记录下分布
        {
        pre = words[i][0];
        temp = 1;
        for(int j=0;j<words[i].length();j++)
        {
           if(words[i][j]==pre)
           {
               e[i][temp].x = words[i][j];
               e[i][temp].times+=1;
               pre = words[i][j];
           }
           else
           {
               temp++;
               e[i][temp].x = words[i][j];
               e[i][temp].times++;
               pre = words[i][j];
           }
        }
        if(temp!=k)//如果分布情况不一样直接弃用
        {
            book[i] = 1;
        }
        }
        for(int i = 0;i<words.size();i++)
        {
            int flag = 0;
            for(int j = 1;j<=k;j++)
            {
                if(book[i]==1)
                {
                    flag = 0;
                    break;
                }
                if(e[i][j].x!=e[100][j].x)//单词出现的顺序不一样
                {
                    flag = 0;
                    break;
                }
                else{
                    if(e[i][j].times>e[100][j].times)//已经大于,不存在扩张
                    {
                        flag = 0;
                        break;
                    }
                    else{
                        if(e[100][j].times==e[i][j].times)
                        {
                            flag++;
                        }
                        else if(e[100][j].times-e[i][j].times>=0&&e[100][j].times>=3)
                        {

                            flag++;
                        }
                    }
                }
            }
            if(flag==k)//得到相同分布,ans++
            {
                ans++;
            }
        }
        return ans;
    } 
};
————————

有时候人们会用重复写一些字母来表示额外的感受,比如 “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 <= 1001 <= words[i].length <= 100s 和所有在 words 中的单词都只由小写字母组成。

思路:n方暴力,一趟n方用结构体存下每个字符转的连续相同字母的区间个数和大小,然后再来一趟n方比较s和每个words,注意题意中是组扩展成组,”oo”可以扩展为”ooo”,只要扩展后的长度>=3就行.

class Solution {
    int book[105] = {0};
    struct node
    {
        char x;
        int use = 1;//若果字符顺序不匹配直接弃用
        int times = 0;//连续相同字符的长度
    }e[105][105];
    int ans=0;
public:
    int expressiveWords(string s, vector<string>& words) {
        char pre = s[0];
        int temp = 1;
        for(int i = 0;i<s.length();i++)//记录下s的字符分布情况
        {
           if(s[i]==pre)
           {
               e[100][temp].x = s[i];
               e[100][temp].times+=1;
               pre = s[i];
           }
           else
           {
               temp++;
               e[100][temp].x = s[i];
               e[100][temp].times++;
               pre = s[i];
           }
        }
        int k = temp;
        //cout<<k<<endl;
        for(int i = 0;i<words.size();i++)//对每一个words也记录下分布
        {
        pre = words[i][0];
        temp = 1;
        for(int j=0;j<words[i].length();j++)
        {
           if(words[i][j]==pre)
           {
               e[i][temp].x = words[i][j];
               e[i][temp].times+=1;
               pre = words[i][j];
           }
           else
           {
               temp++;
               e[i][temp].x = words[i][j];
               e[i][temp].times++;
               pre = words[i][j];
           }
        }
        if(temp!=k)//如果分布情况不一样直接弃用
        {
            book[i] = 1;
        }
        }
        for(int i = 0;i<words.size();i++)
        {
            int flag = 0;
            for(int j = 1;j<=k;j++)
            {
                if(book[i]==1)
                {
                    flag = 0;
                    break;
                }
                if(e[i][j].x!=e[100][j].x)//单词出现的顺序不一样
                {
                    flag = 0;
                    break;
                }
                else{
                    if(e[i][j].times>e[100][j].times)//已经大于,不存在扩张
                    {
                        flag = 0;
                        break;
                    }
                    else{
                        if(e[100][j].times==e[i][j].times)
                        {
                            flag++;
                        }
                        else if(e[100][j].times-e[i][j].times>=0&&e[100][j].times>=3)
                        {

                            flag++;
                        }
                    }
                }
            }
            if(flag==k)//得到相同分布,ans++
            {
                ans++;
            }
        }
        return ans;
    } 
};