算法题 匹配子序列的单词数

原创 于 2025-12-19 16:06:41 发布 · 363 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

匹配子序列的单词数

问题描述

给定字符串 s 和一个字符串数组 words，返回 words 中是 s 的子序列的单词数目。

子序列：通过删除 s 中的一些字符（也可以不删除）而不改变剩余字符相对位置所形成的新字符串。

示例：

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

算法思路

暴力：

  • 对每个单词都从头开始在 s 中匹配
  • 时间复杂度：O(words.length × s.length × avg_word_length)
  • 对于大量重复单词会重复计算

方法：

  1. 预处理 + 二分查找：为每个字符预处理其在 s 中的位置，然后对每个单词使用二分查找
  2. 多指针：为每个单词维护一个指针，同时遍历 s
  3. 缓存：使用哈希表缓存已计算的结果，避免重复单词的重复计算

代码实现

方法一：预处理 + 二分查找

import java.util.*;

class Solution {
    /**
     * 使用预处理和二分查找判断子序列
     * 
     * @param s     源字符串
     * @param words 单词数组
     * @return 是s的子序列的单词数目
     */
    public int numMatchingSubseq(String s, String[] words) {
        // 1: 预处理 - 为每个字符记录其在s中出现的所有位置
        List<Integer>[] positions = new List[26];
        for (int i = 0; i < 26; i++) {
            positions[i] = new ArrayList<>();
        }
        
        for (int i = 0; i < s.length(); i++) {
            positions[s.charAt(i) - 'a'].add(i);
        }
        
        // 2: 使用缓存避免重复计算
        Map<String, Boolean> cache = new HashMap<>();
        int count = 0;
        
        // 3: 对每个单词判断是否为子序列
        for (String word : words) {
            if (cache.containsKey(word)) {
                if (cache.get(word)) {
                    count++;
                }
                continue;
            }
            
            boolean isSubseq = isSubsequence(word, positions);
            cache.put(word, isSubseq);
            if (isSubseq) {
                count++;
            }
        }
        
        return count;
    }
    
    /**
     * 使用二分查找判断单词是否为子序列
     * 
     * @param word      待检查的单词
     * @param positions 字符位置预处理数组
     * @return true表示是子序列，false表示不是
     */
    private boolean isSubsequence(String word, List<Integer>[] positions) {
        int prevIndex = -1; // 上一个匹配字符在s中的位置
        
        for (char c : word.toCharArray()) {
            List<Integer> charPositions = positions[c - 'a'];
            
            // 如果字符c在s中不存在，直接返回false
            if (charPositions.isEmpty()) {
                return false;
            }
            
            // 二分查找第一个大于prevIndex的位置
            int left = 0, right = charPositions.size();
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (charPositions.get(mid) <= prevIndex) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            
            // 如果没有找到合适的位置
            if (left == charPositions.size()) {
                return false;
            }
            
            // 更新prevIndex为找到的位置
            prevIndex = charPositions.get(left);
        }
        
        return true;
    }
}

方法二：多指针

import java.util.*;

class Solution {
    /**
     * 使用多指针判断子序列
     * 为每个单词维护一个指针，同时遍历s
     */
    public int numMatchingSubseq(String s, String[] words) {
        // 使用缓存避免重复计算
        Map<String, Integer> wordCount = new HashMap<>();
        for (String word : words) {
            wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
        }
        
        // 为每个唯一单词创建指针
        Map<String, Integer> pointers = new HashMap<>();
        for (String word : wordCount.keySet()) {
            pointers.put(word, 0);
        }
        
        int matchedCount = 0;
        
        // 遍历s的每个字符
        for (char c : s.toCharArray()) {
            // 复制需要更新的单词列表
            List<String> toRemove = new ArrayList<>();
            
            // 检查每个单词的当前指针位置
            for (String word : pointers.keySet()) {
                int ptr = pointers.get(word);
                if (ptr < word.length() && word.charAt(ptr) == c) {
                    ptr++;
                    pointers.put(word, ptr);
                    
                    // 如果单词完全匹配
                    if (ptr == word.length()) {
                        matchedCount += wordCount.get(word);
                        toRemove.add(word);
                    }
                }
            }
            
            // 移除已完全匹配的单词
            for (String word : toRemove) {
                pointers.remove(word);
            }
        }
        
        return matchedCount;
    }
}

方法三：优化二分查找

import java.util.*;

class Solution {
    /**
     * 使用Collections.binarySearch优化的二分查找
     */
    public int numMatchingSubseq(String s, String[] words) {
        // 预处理字符位置
        List<Integer>[] positions = new List[26];
        for (int i = 0; i < 26; i++) {
            positions[i] = new ArrayList<>();
        }
        
        for (int i = 0; i < s.length(); i++) {
            positions[s.charAt(i) - 'a'].add(i);
        }
        
        Map<String, Boolean> cache = new HashMap<>();
        int count = 0;
        
        for (String word : words) {
            if (cache.computeIfAbsent(word, w -> isSubsequenceOptimized(w, positions))) {
                count++;
            }
        }
        
        return count;
    }
    
    private boolean isSubsequenceOptimized(String word, List<Integer>[] positions) {
        int prevIndex = -1;
        
        for (char c : word.toCharArray()) {
            List<Integer> list = positions[c - 'a'];
            if (list.isEmpty()) return false;
            
            // 使用Collections.binarySearch找到插入位置
            int pos = Collections.binarySearch(list, prevIndex + 1);
            if (pos < 0) {
                pos = -pos - 1; // 转换为插入位置
            }
            
            if (pos >= list.size()) {
                return false;
            }
            
            prevIndex = list.get(pos);
        }
        
        return true;
    }
}

方法四：暴力

import java.util.*;

class Solution {
    /**
     * 暴力双指针，使用缓存优化
     */
    public int numMatchingSubseq(String s, String[] words) {
        Map<String, Boolean> cache = new HashMap<>();
        int count = 0;
        
        for (String word : words) {
            if (cache.computeIfAbsent(word, w -> isSubsequenceBrute(s, w))) {
                count++;
            }
        }
        
        return count;
    }
    
    private boolean isSubsequenceBrute(String s, String word) {
        int i = 0, j = 0;
        while (i < s.length() && j < word.length()) {
            if (s.charAt(i) == word.charAt(j)) {
                j++;
            }
            i++;
        }
        return j == word.length();
    }
}

算法分析

  • 时间复杂度：

    • 预处理 + 二分查找：O(s.length + (word.length × log(s.length)))
    • 多指针：O(s.length × unique_words_count)
    • 暴力（带缓存）：O(s.length × unique_words_count)

  • 空间复杂度：

    • 预处理 + 二分查找：O(s.length + unique_words_count)
    • 多指针：O(unique_words_count × avg_word_length)
    • 暴力：O(unique_words_count × avg_word_length)

算法过程

1：s = “abcde”, words = [“a”,“bb”,“acd”,“ace”]

预处理：

  • positions[‘a’] = [0]
  • positions[‘b’] = [1]
  • positions[‘c’] = [2]
  • positions[‘d’] = [3]
  • positions[‘e’] = [4]

单词检查：

  1. “a”：

    • 字符’a’：在positions[0]中找> -1的位置 → 找到0
    • 完全匹配

  2. “bb”：

    • 第一个’b’：在positions[1]中找> -1的位置 → 找到1
    • 第二个’b’：在positions[1]中找> 1的位置 → 未找到

  3. “acd”：

    • ‘a’：找到位置0，prevIndex=0
    • ‘c’：在positions[2]中找> 0的位置 → 找到2，prevIndex=2
    • ‘d’：在positions[3]中找> 2的位置 → 找到3，prevIndex=3
    • 完全匹配

  4. “ace”：

    • ‘a’：找到位置0，prevIndex=0
    • ‘c’：找到位置2，prevIndex=2
    • ‘e’：在positions[4]中找> 2的位置 → 找到4，prevIndex=4
    • 完全匹配

结果：3个单词匹配

测试用例

public static void main(String[] args) {
    Solution solution = new Solution();
    
    // 测试用例1：标准示例
    String[] words1 = {"a","bb","acd","ace"};
    System.out.println("Test 1: " + solution.numMatchingSubseq("abcde", words1)); // 3
    
    // 测试用例2：重复单词
    String[] words2 = {"a","a","a"};
    System.out.println("Test 2: " + solution.numMatchingSubseq("abcde", words2)); // 3
    
    // 测试用例3：空单词
    String[] words3 = {""};
    System.out.println("Test 3: " + solution.numMatchingSubseq("abcde", words3)); // 1
    
    // 测试用例4：无匹配
    String[] words4 = {"bb","cb","bd"};
    System.out.println("Test 4: " + solution.numMatchingSubseq("abcde", words4)); // 0
    
    // 测试用例5：完全匹配
    String[] words5 = {"abcde"};
    System.out.println("Test 5: " + solution.numMatchingSubseq("abcde", words5)); // 1
    
    // 测试用例6：长字符串
    String longS = "abcdefghijklmnopqrstuvwxyz";
    String[] words6 = {"ace","xyz","aeiou","bcdfg"};
    System.out.println("Test 6: " + solution.numMatchingSubseq(longS, words6)); // 4
    
    // 测试用例7：单字符s
    String[] words7 = {"a","b","c"};
    System.out.println("Test 7: " + solution.numMatchingSubseq("a", words7)); // 1
    
    // 测试用例8：大量重复单词
    String[] words8 = new String[5000];
    Arrays.fill(words8, "ace");
    System.out.println("Test 8: " + solution.numMatchingSubseq("abcde", words8)); // 5000
    
    // 测试用例9：边界情况
    String[] words9 = {"a", "z"};
    System.out.println("Test 9: " + solution.numMatchingSubseq("a", words9)); // 1
    
    // 测试用例10：空s
    String[] words10 = {"a", ""};
    System.out.println("Test 10: " + solution.numMatchingSubseq("", words10)); // 1 (只有空字符串匹配)
}

关键点

  1. 缓存：

    • words 数组可能包含大量重复单词
    • 缓存可以将时间复杂度从 O(total_words) 降低到 O(unique_words)

  2. 二分查找：

    • 预处理每个字符的位置，避免重复遍历 s
    • 对于长 s 和短单词，效率提升

  3. 子序列：

    • 不需要连续，必须保持相对顺序
    • 空字符串是任何字符串的子序列

  4. 字符位置：

    • 使用 ArrayList 存储每个字符的所有位置
    • 位置天然有序，适合二分查找

  5. 边界情况处理：

    • 空字符串、单字符、重复字符等特殊情况
    • 字符在 s 中不存在的情况

常见问题

  1. 为什么需要缓存？

    • words 可能包含重复单词
    • 不缓存会导致重复计算，效率低下

  2. 二分查找？

    • 找第一个大于 prevIndex 的位置
    • 确保字符的相对顺序正确
技术面 - 手撕算法题整理
优快云
03-25 4万+
技术面算法题
华为OD技术面 - 手撕算法题整理
u012657708的博客
02-06 375
华为OD技术面手撕算法
匹配子序列的单词数
青釉Oo的博客
11-21 157
每日一题2022/1117
【C++二分查找 贪心】792. 匹配子序列的单词数|1695
闻缺陷则喜何志丹
08-14 914
给定字符串 s 和字符串数组 words, 返回 words[i] 中是s的子序列的单词个数 。 字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。 例如， “ace” 是 “abcde” 的子序列。
792. 匹配子序列的单词数
qq_45925322的博客
11-17 176
792. 匹配子序列的单词数。 二分查找 状态机预处理
leetcode792：匹配子序列的单词数
m0_63743577的博客
11-17 383
给定字符串 s和字符串数组words, 返回words[i]中是s的子序列的单词个数。 leetcode792：匹配子序列的单词数 字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。
LeetCode每日一题——792. 匹配子序列的单词数
hyk的博客
11-17 739
给定字符串 s 和字符串数组 words, 返回 words[i] 中是s的子序列的单词个数 。 字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。 例如， “ace” 是 “abcde” 的子序列。
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
子序列问-匹配子序列的单词数
qq_45716444的博客
11-17 210
匹配子序列的单词数
Python ：散列表解法 792. 匹配子序列的单词数
Fourier_xyz的博客
11-17 395
字符串的 子序列 是从原始字符串中生成的新字符串，可以从中删去一些字符(可以是none)，而不改变其余字符的相对顺序。一开始就想到用正则匹配秒，没想到超时了。基本上是面向样例编程。
【LeetCode】Day186-匹配子序列的单词数
qq_43417265的博客
11-18 424
792. 匹配子序列的单词数【中等】-二分查找、字符串匹配、三指针、队列
【字符串】【暴力枚举+多指针】1、最长特殊序列I+2、最长特殊序列II+3、判断子序列+4、匹配子序列的单词数+5、追加字符以获得子序列
weixin_50512050的博客
06-17 1132
【字符串】【暴力枚举+多指针】1、最长特殊序列I+2、最长特殊序列II+3、判断子序列+4、匹配子序列的单词数+5、追加字符以获得子序列
力扣hot100：搜索二维矩阵
一本大学生java学习技术分享与交流
12-14 331
二分查找返回的是目标值最先出现的位置或者是在有序数组中的插入位置，如果是在有序数组中的插入位置则可能为在数组最后一个位置加一个数，这是如果进行matrix[i][weizi]==target的判断的话会导致数组越界，必须先处理越界问题，最终判断条件应为weizi<matrix[i].length&&matrix[i][weizi]==target。本题的本质是一个查找算法，为了提高性能可以使用二分查找，这个二维矩阵可以看出许多个数组，只需要对每个数组都进行一次二分查找就可以实现查找整个二维矩阵。
智驾空间智能、物理智能、世界模型相关的最新论文和开源算法链接
Bonaventure的博客
12-16 930
这些资源涵盖了2025年自动驾驶领域的前沿研究，从空间推理到物理建模和世界模拟，提供了丰富的开源工具和理论框架。建议用户通过链接深入探索论文和代码，以应用于实际项目或进一步研究。如果您需要更详细的解读或特定应用建议，请随时补充信息！
(leetcode) 力扣100 15轮转数组（环状替代）
最新发布
qq_62235017的博客
12-18 435
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
从零开始写算法——链表篇4:删除链表的倒数第 N 个结点 + 两两交换链表中的节点
m0_59624833的博客
12-15 815
hot100链表的两道题详解。
从0开始学算法——第十五天（滑动窗口）
2401_84407045的博客
12-13 1434
本文旨在通过实践展示滑动窗口技术的应用，特别是在处理数组或字符串时的高效查找和统计操作。主要包括在给定的数组或字符串中找到满足特定条件的连续子数组或子字符串，旨在提高算法的时间效率和理解窗口滑动的原理与实现。
Leetcode 79 最佳观光组合
im_AMBER的博客
12-17 448
每个元素只遍历一次只用了两个变量O(n)O(1)公式拆分是核心：将原得分公式拆分为，把双变量问题转化为单变量的遍历问题。贪心维护最优值：遍历j时，用best维护之前所有i < j中的最大值，这样每一步只需要 O (1) 计算，整体时间复杂度是 O (n)。遍历顺序：因为要求i < j，所以从j=1开始遍历，先计算当前j的得分，再更新best（避免 j 自己和自己配对）。
匹配子序列的个数的算法 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、付费专栏及课程。

余额充值