每日一题 —— LC. 792 匹配子序列的单词数

最新推荐文章于 2024-08-14 07:00:00 发布
最新推荐文章于 2024-08-14 07:00:00 发布
阅读量818 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/vcj1009784814/article/details/127899316
版权
本文介绍了一种高效的算法来解决字符串子序列匹配的问题，并详细分析了如何利用C++特性优化代码性能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

特此记录！注意以后用C++写题时，能用引用就尽量用引用！

特此记录！注意以后用C++写题时，能用引用就尽量用引用！

特此记录！注意以后用C++写题时，能用引用就尽量用引用！

792. 匹配子序列的单词数

给定字符串 s 和字符串数组 words, 返回 words[i] 中是s的子序列的单词个数 。

字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。

例如， “ace” 是 “abcde” 的子序列。

提示

  • 1 <= s.length <= 5 * 10^4
  • 1 <= words.length <= 5000
  • 1 <= words[i].length <= 50
  • words[i]和 s 都只由小写字母组成。

示例

输入: s = "abcde", words = ["a","bb","acd","ace"]
输出: 3
解释: 有三个是 s 的子序列的单词: "a", "acd", "ace"。

思路

假设待匹配的单词里面有一个字母a，那么我们需要在主串s中找到一个字母a来与之匹配，如果s中存在多个a，那么我们用哪个来匹配呢？答案是最左侧的a，即最早出现的那一个。

因为选择越靠左侧的a，能让其右侧的字母尽可能的多。对于待匹配单词中字母a的下一个字母，假设是b，我们需要从s中，我们选择的字母a后面，再找到一个b来与之匹配。选择最靠左的a，能让其右侧可供选择的字母数量最多，就越有可能匹配到字母b。

举个简单的例子，加入s = cabcade，待匹配单词w = ac，

我们匹配时，先取w的第一个字母，即a，然后尝试在s中找到一个a来与之匹配，而此时s中有2个a，我们应当取哪个呢？当然应该取最左侧的那个。因为这样能让s中右侧剩余部分最长，剩余部分的字母也就越多，就越有可能匹配上w后续的字母。同时需要注意，当我们匹配了第一个a后，在匹配w的第二个字母c时，必须要求s中选择的c，一定要在s中选择的a的右侧。从上面的例子来说，就是我们不能选择s中的第一个c，因为其不在a的右侧。

于是我们的思路就比较清晰了。我们依次遍历待匹配单词w的每个字符，对于当前字符c，每次尝试在主串s中查找这个字符，但是需要注意，查找的c的下标，必须要大于前一个匹配的字符在s中的位置。

即，对于w中每个字符c，我们需要维护一个左边界left，我们在主串s中，查找下标大于left的第一次字符c，设其下标为idx，找到后，我们更新left = idx，此时的left是作为下一个待匹配字符的左边界。

只要对于w中的每个字符，我们都能在s中完成匹配。那么该w就是s的一个子序列。

要完成上述操作，我们需要先遍历一次主串s，将每个字符出现的位置保存下来（某个字符出现多次的话，就保存多个下标）。而每次我们查找字符时，直接取该字符在s中出现的下标数组，并通过二分，查找到第一个大于left的下标即可。

// C++ 144ms
class Solution {
public:

    // 在idx中找到第一个大于left的位置
    int find(vector<int>& idx, int left) {
        // idx可能为空
        if (idx.size() == 0) return -1;
        int l = 0, r = idx.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (idx[mid] > left) r = mid;
            else l = mid + 1;
        }
        if (idx[l] > left) return idx[l];
        return -1;
    }

    int numMatchingSubseq(string s, vector<string>& words) {
        // 由于全是小写字母, 可以直接开一个大小为26的vector
        vector<vector<int>> idx(26);
        // 保存每个字符出现的下标
        for (int i = 0; i < s.size(); i++) {
            idx[s[i] - 'a'].push_back(i);
        }
        int ans = 0;
        for (auto& w : words) {
            int l = -1;
            bool yes = true;
            for (int i = 0; i < w.size(); i++) {
                vector<int>& v = idx[w[i] - 'a']; // 注意这里要加引用 & , 否则会超时
                // 不加引用的话每次取都会拷贝一次, 会非常消耗性能
                l = find(v, l); // 这里可以直接用 upper_bound 函数替代
                if (l == -1) {
                    yes = false;
                    break;
                }
            }
            if (yes) ans++;
        }
        return ans;
    }
};

也可以用STL中的upper_bound函数来替代自实现的二分查找

// C++ 144ms
class Solution {
public:
    int numMatchingSubseq(string s, vector<string>& words) {
        // 由于全是小写字母, 可以直接开一个大小为26的vector
        vector<vector<int>> idx(26);
        // 保存每个字符出现的下标
        for (int i = 0; i < s.size(); i++) {
            idx[s[i] - 'a'].push_back(i);
        }
        int ans = 0;
        for (auto& w : words) {
            int l = -1;
            bool yes = true;
            for (int i = 0; i < w.size(); i++) {
                vector<int>& v = idx[w[i] - 'a']; // 注意这里要加引用 & , 否则会超时
                // 不加引用的话每次取都会拷贝一次, 会非常消耗性能
                vector<int>::iterator it = upper_bound(v.begin(), v.end(), l);
                // upper_bound是查找第一个 > 某个数的
                // lower_bound是查找第一个 >= 某个数的
                if (it == v.end()) {
                    // 没找着
                    yes = false;
                    break;
                }
                l = *it; //找着了, 更新left边界
            }
            if (yes) ans++;
        }
        return ans;
    }
};

今早做这道题时，我自己想出了二分的做法，但是提交一直TLE。最后针对几个样例数据，加了set做缓存+去重，以及对一些情况加了些特判，才勉强通过。

image-20221117102733637

非常艰难的AC！！下面是我TLE的代码

class Solution {
public:

    // 在idx中找到第一个大于left的位置
    int find(vector<int>& idx, int left) {
        int l = 0, r = idx.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (idx[mid] > left) r = mid;
            else l = mid + 1;
        }
        if (idx[l] > left) return idx[l];
        return -1;
    }

    // 4 × 10^6
    int numMatchingSubseq(string s, vector<string>& words) {
        // 只包含小写字母, 可以存储一下每个字母第一次出现时的位置, 哈哈哈
        unordered_map<int, vector<int>> idx;
        for (int i = 0; i < s.size(); i++) {
            int u = s[i] - 'a';
            idx[u].push_back(i);
        }
        // for (auto& [k, v] : idx) {
        //     char c = k + 'a';
        //     printf("char = %c : -> ", c);
        //     for (auto& i : v) printf("%d, ", i);
        //     printf("\n");
        // }

        int ans = 0;
        for (auto& w : words) {
            // printf("word = %s, ", w.c_str());
            int cnt = 0, l = -1;
            for (int i = 0; i < w.size(); i++) {
                int u = w[i] - 'a';
                if (idx.find(u) == idx.end()) break;
                vector<int> v = idx.find(u)->second;
                l = find(v, l);
                // printf("char = %c, idx = %d; ", w[i], l);
                if (l == -1) break; // 没找着
                cnt++;
            }
            if (cnt == w.size()) {
                // printf("yes!");
                ans++;
            }
            // printf("\n");
        }
        return ans;
    }
};

可以看到我加了很多print进行反复调试。下面是我加了set做缓存，加了一些特判后勉强AC的代码。

// C++ 1248ms
class Solution {
public:

    // 在idx中找到第一个大于left的位置
    int find(vector<int>& idx, int left) {
        int l = 0, r = idx.size() - 1;
        while (l < r) {
            // printf("%d次二分", c);
            if (left == -1) break; // 第一次, 直接break, 取l = 0
            int mid = l + r >> 1;
            if (idx[mid] > left) r = mid;
            else l = mid + 1;
        }
        if (idx[l] > left) return idx[l];
        return -1;
    }

    // 4 × 10^6
    int numMatchingSubseq(string s, vector<string>& words) {
        // 只包含小写字母, 可以存储一下每个字母第一次出现时的位置, 哈哈哈
        unordered_map<char, vector<int>> idx;
        for (int i = 0; i < s.size(); i++) {
            idx[s[i]].push_back(i);
        }
        // for (auto& [k, v] : idx) {
        //     printf("char = %c : -> ", k);
        //     for (auto& i : v) printf("%d, ", i);
        //     printf("\n");
        // }
        // 缓存已判断过的单词
        unordered_set<string> valid;
        unordered_set<string> invalid;
        int ans = 0;
        for (auto& w : words) {
            if (valid.count(w)) {
                ans++;
                continue;
            }
            if (invalid.count(w)) continue;
            // printf("word = %s, ", w.c_str());
            int cnt = 0, l = -1;
            for (int i = 0; i < w.size(); i++) {
                char u = w[i];
                if (idx.find(u) == idx.end()) break;
                vector<int> v = idx.find(u)->second;
                l = find(v, l);
                // printf("char = %c, idx = %d; ", w[i], l);
                if (l == -1) break; // 没找着
                cnt++;
            }
            if (cnt == w.size()) {
                // printf("yes!");
                ans++;
                valid.emplace(w);
            } else {
                invalid.emplace(w);
            }
            // printf("\n");
        }
        return ans;
    }
};

后来看题解，发现别人的思路和我的一样，但是用别人的代码提交，就运行非常快。我非常纳闷，一行一行代码的进行对比，删除调试。

最后发现，是因为我后面取vector时，没有加引用导致的！

然后我把上面那份TLE的代码，只多加了一个引用符号 &，就AC了，跑了180ms

就是这句

vector<int> v = idx.find(u)->second;

多加了引用符号，改成了

vector<int>& v = idx.find(u)->second;

C++中如果不加&，会默认进行数据拷贝，所以会非常吃性能！

下次一定要注意，从容器中取数据时，尽可能的使用引用！

但同时也要注意，使用引用取出的数据，修改就是直接在原数据上修改！而不是在数据的副本上修改。

792. 匹配子序列的单词数
苏小丫的博客
02-15 468
给定字符串 S 和单词字典 words, 求words[i]中是S的子序列的单词个数。 示例 输入: S = "abcde" words = ["a", "bb", "acd", "ace"] 输出: 3 解释: 有三个是S 的子序列的单词: "a", "acd", "ace"。 注意: 所有在words和S里的单词都只由小写字母组成。 S 的长度在[1, 50000]...
leetcode 792. Number of Matching Subsequences | 792. 匹配子序列的单词数（Java）
热门推荐
寒泉
12-21 3万+
题目 https://leetcode.com/problems/number-of-matching-subsequences/ 题解 一看数据规模，普通暴力解法肯定超时了。想了半天怎么用 Trie，没有想出来，于是直奔评论区。 作者的代码很简洁易懂，看完之后自己写了一遍。 class Solution { public int numMatchingSubseq(String s, String[] words) { ArrayList<StringBuilder&gt
Leetcode 792. 匹配子序列的单词数 C++
weixin_43750513的博客
08-04 423
Leetcode 792. 匹配子序列的单词数 题目 给定字符串 S 和单词字典 words, 求 words[i] 中是 S 的子序列的单词个数。 示例: 输入: S = "abcde" words = ["a", "bb", "acd", "ace"] 输出: 3 解释: 有三个是 S 的子序列的单词: "a", "acd", "ace"。 注意: 所有在words和 S 里的单词都只由小写字母组成。 S 的长度在 [1, 50000]。 words 的长度在 [1, 5000]。 words[i
leetcode-792-匹配子序列的单词数-C语言
SFFS
05-27 404
/* * 算法思想： * 使用暴力匹配法会超时。 * 将每个字母出现的index用一个数组记录下来，同时记录其出现次数； * 匹配时，直接在该数组中寻找是否出现过该字母，并且该字母出现的index大于上次匹配的index 代码中的last。 * 分别对每个单词进行匹配，累加结果即可。 * */ #define LEN 0xffff typedef struct node_t{ ...
【C++二分查找 贪心】792. 匹配子序列的单词数|1695
闻缺陷则喜何志丹
08-14 858
给定字符串 s 和字符串数组 words, 返回 words[i] 中是s的子序列的单词个数 。 字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。 例如， “ace” 是 “abcde” 的子序列。
LC-792. 匹配子序列的单词数（二分查找、字典树+DFS）
qq_42958831的博客
11-23 448
难度中等242给定字符串s和字符串数组words, 返回 words[i]中是s的子序列的单词个数。字符串的是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。
792 匹配子序列的单词数
weixin_44171872的博客
02-09 245
题目描述： 给定字符串 S 和单词字典 words, 求 words[i] 中是 S 的子序列的单词个数。 示例: 输入: S = “abcde” words = [“a”, “bb”, “acd”, “ace”] 输出: 3 解释: 有三个是 S 的子序列的单词: “a”, “acd”, “ace”。 注意: 所有在words和 S 里的单词都只由小写字母组成。 S 的长度在 [1, 50000]。 words 的长度在 [1, 5000]。 words[i]的长度在[1, 50]。 方法1： 主要思路：
有丝分裂和减数分裂测试题——已整理——精品.doc
11-12
- 第18题，初级精母细胞在减数分裂前染色体数为32，四分体数为16，染色单体数和DNA分子数均为64。 - 最后，第19题的图示中，细胞内没有同源染色体，表明它可能是次级精母细胞或卵母细胞，处在减数第二次分裂的过程...
JAVA程序设计：匹配子序列的单词数自定义字符串排序（LeetCode：792）
信仰.的博客
03-14 519
给定字符串 S 和单词字典 words, 求words[i]中是S的子序列的单词个数。 示例: 输入: S = "abcde" words = ["a", "bb", "acd", "ace"] 输出: 3 解释: 有三个是S 的子序列的单词: "a", "acd", "ace"。 注意: 所有在words和S里的单词都只由小写字母组成。 S 的长度在[1, 50000]。 ...
题792、匹配子序列的单词数
weixin_45980031的博客
03-01 216
一、题目1 二、思路 非常简单粗暴，循环遍历整个S和words[i]中的每一个字符，然后进行判断就行了。但是因为题目输入中存在相当多的相同字符串和非常长的字符串S，所以自然而然的就超时了。 下面是未优化过的代码： public int numMatchingSubseq(String S, String[] words) { int count = 0; ...
LeetCode792. 匹配子序列的单词数
fsdgfsf的博客
02-27 255
思路： 1.爆破法，对每个单词进行比对，但是超时 2,考虑只遍历S一次 class Solution { public int numMatchingSubseq(String S, String[] words) { HashMap<Character,ArrayList<String>> map = new HashMap<>()...
力扣每日一题：792. 匹配子序列的单词数【真没想到是一个二分】
weixin_54046648的博客
11-17 751
我们可以先试一下暴力去解决，用双指针，一根指针指向字符串s，还有一根指针指向words【i】，然后循环，进行比较，如果字符相同，就都向后移动一格，如果不想等，指向字符串s的之指针往后移一格。那么对于需要匹配的字符 t[j] 我们就可以通过在对应的 pos数组中进行「二分查找」来找到第一个大于当前 i指针的位置，若不存在则说明匹配不成功，否则就将指针 iii 直接移到找到的对应位置，并将指针 j后移一个单位，这样就加速了指针 i的移动。有三个是 s 的子序列的单词: "a", "acd", "ace"。
每天一道LeetCode-----给定字符串s和字符数组words，在s中找到words出现的位置，words内部字符串顺序无要求
一个程序渣渣的小后院
10-28 3729
Substring with Concatenation of All Words原题链接Substring with Concatenation of All Words 题目意思是给定字符串s和字符数组words，在s中寻找words出现的位置，words内部的字符串顺序没有要求此问题可以直接顺序搜索，假设s的长度为m，words的长度为n，words中每个单词的长度为w，复杂度是O((m
【LeetCode】792. 匹配子序列的单词数
weixin_43894455的博客
11-17 790
day17 二分查找、分桶、分桶优化
给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。 s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。例如，如果
qq_43958998的博客
03-21 699
【代码】给定一个字符串 s 和一个字符串数组 words。words 中所有字符串 长度相同。s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。例如，如果。
LeetCode每日一题——792. 匹配子序列的单词数
hyk的博客
11-17 706
给定字符串 s 和字符串数组 words, 返回 words[i] 中是s的子序列的单词个数 。 字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。 例如， “ace” 是 “abcde” 的子序列。
leetcode做题笔记30
si_mple_的博客
07-15 369
例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。本题想到直接将words中字符直接排列组合后进行比较，若匹配成功则记录该下标，实际编写的过程中对于是否到达边界的判断有点无从下手，在想明白用top来记录顺序是否已经排列完全后问题迎刃而解。思路一：模仿题意作答，将words中的数不断转换顺序与s中字符比较，输出匹配成功的下标。你可以以 任意顺序 返回答案。
匹配子序列的个数的算法 c++
最新发布
09-11
C++中有两种方法可以解决给定字符串`s`匹配一组子序列（words）的数量问题： **方法一：分桶优化法 (时间复杂度O(nm))[^1]** ```cpp class Solution { public: int numMatchingSubseq(string s, vector<string>&& words) { vector<queue<string>> d(26); // 分桶依据单词首字母 for(const auto &w : words) d[w[0] - 'a'].enqueue(w); int res = 0; for(char &c : s) { auto &q = d[c - 'a']; while(!q.empty()) { auto t = q.front(); q.dequeue(); if(t.size() == 1) res++; // 如果字符匹配，计数加一 else d[t[1] - 'a'].enqueue(t.substr(1)); } } return res; } }; ``` 在这个方法中，我们把每个单词按照第一个字符分组，然后遍历`s`，每次从对应桶中取出一个子串，如果当前字符匹配，就递减子串长度，直到遇到非空子串。 **方法二：朴素暴力法 (时间复杂度O(n*m*words.size()))** ```cpp class Solution { public: bool isSubseq(string &s, string subS) { for(int i = 0, j = 0; i < s.size(); i++) { if(s[i] == subS[j]) { j++; if(j == subS.size()) return true; } } return false; } int numMatchingSubseq(string s, vector<string>&& words) { int res = 0; for(int i = 0; i < words.size(); i++) { if(isSubseq(s, words[i])) res++; } return res; } }; ``` 这个方法更简单，但效率较低，因为它对于每一个`words`中的子串，都会独立地在`s`中进行逐字符的比较。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值