单词分割匹配字典

已于 2022-02-12 14:15:51 修改
阅读量6.8k 收藏 4
点赞数
分类专栏： leetcode 文章标签： leetcode 算法 职场和发展
于 2022-02-12 10:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HUBA_yosa/article/details/122893419
版权

问题

给定一个字符串s和一个单词字典dict，确定s是否可以被分割成一个或多个字典单词的空格分隔序列。例如，给定s =“leetcode”， dict = [“leet”， “code”]。返回true，因为"leetcode"可以被分割为“leet code”。

解决方案

1. 朴素方法

这个问题可以通过使用一种简单的方法来解决。讨论总是可以从这开始。

public static boolean wordBreak1(String s, Set<String> dict) {
    return wordBreak1(s, dict, 0);
}

// 参数start指的是字符串的字符索引
public static boolean wordBreak1(String s, Set<String> dict, int start) {
    // 分割到末尾 视为成功
    if (start == s.length()) {
        return true;
    }
    // 遍历字典
    for (String a : dict) {
        int len = a.length();
        int end = len + start;
        if (end > s.length()) {
            continue;
        }
        if (s.substring(start, start + len).equals(a)) {
            // 对剩余的子串进行字典匹配
            if (wordBreak1(s, dict, start + len)) {
                return true;
            }
        }
    }
    return false;
}

时间:O (n2)，此解决方案超出时间限制。

2. 动态规划法

采用动态规划方法解决该问题的关键是:

  • 定义一个数组t[]，使t[i]==true =>0-(i-1)可以使用字典进行分段；
  • 初始状态 t[0]==true；
public static boolean wordBreak2(String s, Set<String> dict) {
    boolean[] t = new boolean[s.length() + 1];
    t[0] = true;

    for (int i = 0; i < s.length(); i++) {
        if (!t[i]) {
            continue;
        }
        // 只有t[i]=true时继续往下匹配 否则跳过
        for (String a : dict) {
            int len = a.length();
            int end = i + len;
            if (end > s.length()) {
                continue;
            }
            if (t[end]) {
                continue;
            }
            if (s.substring(i, end).equals(a)) {
                t[end] = true;
            }
        }
    }
    return t[s.length()];
}

时间:O(字符串长度*字典大小)

这个解决方案中一个棘手的部分是:我们应该找到所有可能的匹配，而不是停留在“程序目标”。

3. 正则表达式

这个问题应该等同于匹配正则表达式 (leet|code)*，这意味着它可以通过在O(2^m)中构建一个DFA并在O(n)中执行来解决。Leetcode在线评判不允许使用Pattern类。

public static void main(String[] args) {
    String s = "leetcode";
    Set<String> dict = new HashSet<>();
    dict.add("leets");
    dict.add("leet");
    dict.add("code");

    StringBuilder sb = new StringBuilder();
    for (String str : dict) {
        sb.append(str + "|");
    }
    String pattern = sb.toString().substring(0, sb.length() - 1);
    pattern = "(" + pattern + ")*";
    Pattern p = Pattern.compile(pattern);
    // 正则表达式 (leets|leet|code)*
    Matcher m = p.matcher("leetcode");
    boolean matches = m.matches();
    if (m.matches()) {
        System.out.println("true");
    }
}

问题

给定一个字符串s和一个单词字典dict，确定s是否可以被分割成一个或多个字典单词的空格分隔序列。例如，给定s =“leetcode”， dict = [“leet”， “code”]。返回true，因为"leetcode"可以被分割为“leet code”。

解决方案

1. 朴素方法

这个问题可以通过使用一种简单的方法来解决。讨论总是可以从这开始。

public static boolean wordBreak1(String s, Set<String> dict) {
    return wordBreak1(s, dict, 0);
}

// 参数start指的是字符串的字符索引
public static boolean wordBreak1(String s, Set<String> dict, int start) {
    // 分割到末尾 视为成功
    if (start == s.length()) {
        return true;
    }
    // 遍历字典
    for (String a : dict) {
        int len = a.length();
        int end = len + start;
        if (end > s.length()) {
            continue;
        }
        if (s.substring(start, start + len).equals(a)) {
            // 对剩余的子串进行字典匹配
            if (wordBreak1(s, dict, start + len)) {
                return true;
            }
        }
    }
    return false;
}

时间:O (n2)，此解决方案超出时间限制。

2. 动态规划法

采用动态规划方法解决该问题的关键是:

  • 定义一个数组t[]，使t[i]==true =>0-(i-1)可以使用字典进行分段；
  • 初始状态 t[0]==true；
public static boolean wordBreak2(String s, Set<String> dict) {
    boolean[] t = new boolean[s.length() + 1];
    t[0] = true;

    for (int i = 0; i < s.length(); i++) {
        if (!t[i]) {
            continue;
        }
        // 只有t[i]=true时继续往下匹配 否则跳过
        for (String a : dict) {
            int len = a.length();
            int end = i + len;
            if (end > s.length()) {
                continue;
            }
            if (t[end]) {
                continue;
            }
            if (s.substring(i, end).equals(a)) {
                t[end] = true;
            }
        }
    }
    return t[s.length()];
}

时间:O(字符串长度*字典大小)

这个解决方案中一个棘手的部分是:我们应该找到所有可能的匹配，而不是停留在“程序目标”。

3. 正则表达式

这个问题应该等同于匹配正则表达式 (leet|code)*，这意味着它可以通过在O(2^m)中构建一个DFA并在O(n)中执行来解决。Leetcode在线评判不允许使用Pattern类。

public static void main(String[] args) {
    String s = "leetcode";
    Set<String> dict = new HashSet<>();
    dict.add("leets");
    dict.add("leet");
    dict.add("code");

    StringBuilder sb = new StringBuilder();
    for (String str : dict) {
        sb.append(str + "|");
    }
    String pattern = sb.toString().substring(0, sb.length() - 1);
    pattern = "(" + pattern + ")*";
    Pattern p = Pattern.compile(pattern);
    // 正则表达式 (leets|leet|code)*
    Matcher m = p.matcher("leetcode");
    boolean matches = m.matches();
    if (m.matches()) {
        System.out.println("true");
    }
}

对上面问题的进行引申，抛出一个新的问题。

问题

给定一个字符串s和一个单词字典dict，在s中添加空格来构造一个句子，其中每个单词都是字典中的有效单词，返回所有这些可能的句子。

例如，给定s = “catsanddog”， dict = [“cat”， “cats”， “and”， “sand”， “dog”]，解决方案是[“cats anddog”， “catsanddog”]。

解决方案

1. 动态规划法

这个问题与上面的单词分割非常相似。我们需要跟踪实际的单词，而不是使用布尔数组（上面的单词分割）来跟踪匹配位置。然后，我们可以使用深度优先搜索来获取所有可能的路径，即字符串列表。

下图显示了跟踪阵列的结构：

在这里插入图片描述

public static List<String> wordBreak(String s, Set<String> dict) {
        List<String> dp[] = new ArrayList[s.length() + 1];
        dp[0] = new ArrayList<>();

        for (int i = 0; i < s.length(); i++) {
            if (dp[i] == null) {
                continue;
            }

            for (String word : dict) {
                int len = word.length();
                int end = len + i;
                if (end > s.length()) {
                    continue;
                }
                if (s.substring(i, end).equals(word)) {
                    if (dp[end] == null) {
                        dp[end] = new ArrayList<String>();
                    }
                    dp[end].add(word);
                }
            }
        }
        List<String> result = new LinkedList<>();
        if (dp[s.length()] == null) {
            return result;
        }
        ArrayList<String> temp = new ArrayList<>();
        dfs(dp, s.length(), result, temp);

        return result;
    }

    public static void dfs(List<String> dp[], int end, List<String> result, ArrayList<String> tmp) {
        // 倒序打印路径
        if (end <= 0) {
            String path = tmp.get(tmp.size() - 1);
            for (int i = tmp.size() - 2; i >= 0; i--) {
                path += " " + tmp.get(i);
            }
            result.add(path);
            return;
        }
        for (String str : dp[end]) {
            tmp.add(str);
            dfs(dp, end - str.length(), result, tmp);
            // 删除以当前str的方案
            tmp.remove(tmp.size() - 1);
        }
    }

2. 测试代码

public static void main(String[] args) {
    String s = "catsanddog";
    Set<String> dict = new HashSet<>();
    dict.add("sand");
    dict.add("and");
    dict.add("cats");
    dict.add("cat");
    dict.add("dog");
    System.out.println(wordBreak(s,dict));
}

结果：

[cat sand dog, cats and dog]

进程已结束，退出代码 0
CodeHuba
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
英文单词分割symspellpy库依赖词典
05-20
symspellpy是可以进行文本的纠错，也可以将连在一起的字母分割成若干个单词的。根据实践表示该文件还是比较好用的，该文件是它的字典库。具体使用可参考博客...
单词拆分（字典数）
m0_59883718的博客
05-19 128
很强
python 字典快速匹配
热门推荐
ouprince
07-03 1万+
有时候我们在生成模型的时候，会出现在一个好 几十万 的字典 dict 里面匹配数据，但往往这种方法造成的时间损耗是巨大的。 比如以下代码： # word_index 就是有几十万数据的词汇字典 # post 就是分词后的文档 for w in post.split(" "): if w in word_index.keys(): word_model.append(w...
【Python_字典】字典匹配
越努力，越幸运
06-02 2277
参考 https://www.gxlcms.com/python-363836.html
Python用字典完成匹配任务
小白皮皮
10-11 3218
1. 问题描述 如下左图为编号与gene名称的对应关系（此处仅显示前10条），已存为字典（map_gene），右图为我们需要去匹配的gene名称，如何根据基因名称给出对应的编号？      2. 解决方案 2.1 定义变量 首先，我们定义一个空的list来存储gene对应的编号，且因部分gene在字典map_gene中不存在，故需记录可匹配到的个数。 # 定义变量...
词典快速匹配方案
qq_25956141的博客
10-04 1615
介绍 对于构造了几百万上千万的集合中，快速查找对应的元素是一种常见的应用场景，因此本文将探讨一种如何在一个大集合中快速查找对应元素的方法。 查找方案 哈希查找和字典树是两种高性能的查找方法。其中字典树使用最长前缀匹配法，其查找速度非常快，但由于更新时需要调整整个树，导致其更新速度较慢，因此字典树不适用于动态集合。而哈希查找解决了更新速度慢的问题，因此本文主要介绍基于哈希查找的词典匹配方法。 本文将...
SAP常用单词中英文字典.xls
01-26
SAP常用单词中英文字典.xls
fenci.rar_匹配字典_最大匹配 分词
09-23
正向最大匹配算法分词，采用容器储存字典可提高一定的效率。
Java实现 LeetCode 524 通过删除字母匹配到字典里最长单词（又是一道语文题）
12-21
524. 通过删除字母匹配到字典里最长单词 给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。...
shujujiegou.rar_单词基数排序_字典序
09-20
试设计一个将一组英文单词按字典序排列的基数排序算法。设单词均由小写字母或空格构成，最长的单词有MaxLen个字母
poj1035 字典匹配
chchlh的专栏
01-09 590
//终于过了，主要思想是强制计算所有可能长度对应的子字典列表。 //用空间换时间 1324K 938MS #include #include using namespace std; string dic[10005]; string check; int len[10005]; int indexLen[16][10005]; int cntt[16]; int subList[16][1
python实现快速匹配_python – 最快的字典匹配
weixin_39760389的博客
12-05 1250
我将不得不在Python中执行类似拼写检查的操作,如下所示：我有一个巨大的单词列表(让我们称之为词典).我现在给了一些文本(我们称之为样本).我必须在词典中搜索每个样本单词.如果我找不到它,那个样本字就是错误.简而言之 – 一个蛮力拼写检查器.但是,对每个样本字线性搜索词典必然会很慢.有什么更好的方法呢？复杂因素是样本和词典都不是英文的.它是一种语言而不是26个字符,可以有超过300个 – 以Un...
匹配字典 dict python3
小沙粒看未来
12-27 309
from collection import Counter counter = Counter({"book":1,"football":2,"light:"3}) list=["book","pen","light"] for keyin list: if key in list(counter.keys()): print("i am the list and th...
借由字典的匹配学习类中方法的调用
qq_33834267的博客
06-02 180
现在有两个字典，想要根据id匹配。但这不是目的，我想尝试的是类中方法的自调用和局部，全局变量的用法。#coding : utf-8 class MatchCase(object): def __init__(self, case_1, case_2): # 定义类的属性参数 self.case_1 = case_1 self.case_2 = case_2 ...
判断字符串能否根据给定的词典划分 Word Break
weixin_34279579的博客
09-29 267
为什么80%的码农都做不了架构师？>>> ...
切词分词之判断字符串是否能够拆分为字段中的单词
zwan0518的专栏
10-15 2985
给定字符串，以及一个字典，判断字符串是否能够拆分为字段中的单词。给出递归和DP解决办法
字符串分割
jiangkun0331的博客
08-03 167
字符串分割(Word Break) 难度：Medium 备注：出自leetcode 题目描述 Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words. For example, given s =“leetcode”, dict =[“leet”, “code”]. Retur
LintCode 107 给定字符串 s 和单词字典 dict，确定 s 是否可以分成一个或多个以空格分隔的子串，并且这些子串都在字典中存在。
TERMINATOR-FOR-EVER
09-10 1686
代码一、使用递归算法，超时 class Solution { public: /* * @param s: A string * @param dict: A dictionary of words dict * @return: A boolean */ bool wordBreak(string &s, unordered_s...
判断字符串是否能分割成字典中的单词（二）——Leetcode系列（十二）
Hooting的码农笔记本
06-29 3353
Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences. For example, given s = "
给你一个下标从 0 开始的字符串 s 和一个单词字典 dictionary 。你需要将 s 分割成若干个 互不重叠 的子字符串，每个子字符串都在 dictionary 中出现过。s 中可能会有一些 额外的字符 不在任何子字符串中。 请你采取最优策略分割 s ，使剩下的字符 最少 。c语言实现
最新发布
05-28
以下是使用动态规划算法，采用 C 语言实现的代码： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_N 1000 #define MAX_WORD_LENGTH 50 #define INF 0x3f3f3f3f int dp[MAX_N + 1]; char s[MAX_N + 1]; char dictionary[MAX_N][MAX_WORD_LENGTH + 1]; int word_count; typedef struct TrieNode { int is_word; struct TrieNode* children[26]; } TrieNode; TrieNode* create_trie_node() { TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode)); node->is_word = 0; memset(node->children, 0, sizeof(node->children)); return node; } void insert_word(TrieNode* root, char* word) { TrieNode* node = root; while (*word) { int idx = *word - 'a'; if (!node->children[idx]) { node->children[idx] = create_trie_node(); } node = node->children[idx]; ++word; } node->is_word = 1; } int search_word(TrieNode* root, char* word) { TrieNode* node = root; while (*word) { int idx = *word - 'a'; if (!node->children[idx]) { return 0; } node = node->children[idx]; ++word; } return node->is_word; } int main() { scanf("%s", s); scanf("%d", &word_count); TrieNode* root = create_trie_node(); for (int i = 0; i < word_count; ++i) { scanf("%s", dictionary[i]); insert_word(root, dictionary[i]); } int n = strlen(s); memset(dp, INF, sizeof(dp)); dp[0] = 0; for (int i = 1; i <= n; ++i) { for (int j = 0; j < i; ++j) { if (dp[j] != INF && search_word(root, s + j, i - j)) { dp[i] = dp[i] < dp[j] + i - j ? dp[i] : dp[j] + i - j; } } } printf("%d\n", dp[n]); return 0; } ``` 其中，我们使用了一个 Trie 树来存储字典中的单词， Trie 树是一种高效的数据结构，可以用来快速查找字符串。在 insert_word 函数中，我们依次遍历要插入的单词的每一个字符，将其插入到 Trie 树中，如果该节点的 children 数组中没有对应的字符，则新建一个 TrieNode 节点。在 search_word 函数中，我们依次遍历要查询的字符串的每一个字符，判断该字符在当前节点的 children 数组中是否存在，如果存在，则继续遍历，否则返回 0。 在主函数中，我们首先读入字符串 s 和字典 dictionary，然后依次将字典中的单词插入到 Trie 树中。接下来，我们使用动态规划算法，定义一个数组 dp，其中 dp[i] 表示将字符串 s 的前 i 个字符分割成若干个互不重叠的子字符串，每个子字符串都在字典 dictionary 中出现过，剩余的字符数最少是多少。初始时，我们将 dp 数组中所有元素的值都赋为 INF，表示目前还没有找到符合要求的分割方案。接下来，我们使用双重循环来遍历字符串 s 中的所有子串，判断每个子串是否在字典 dictionary 中出现过，并且以该子串为结尾的字符串能否被拆分。如果可以，更新 dp 数组的值。最终，当 dp[n] 的值不为 INF 时，表示字符串 s 可以被拆分成若干个互不重叠的子字符串，使得每个子字符串都在字典 dictionary 中出现过，剩余的字符数最少是 dp[n]。 时间复杂度为 O(n^3)，空间复杂度为 O(n^2)，其中 n 是字符串 s 的长度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值