单词分割匹配字典

已于 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
    评论
专栏目录
单词拆分（字典数）
m0_59883718的博客
05-19 132
很强
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 2285
参考 https://www.gxlcms.com/python-363836.html
Python用字典完成匹配任务
小白皮皮
10-11 3221
1. 问题描述 如下左图为编号与gene名称的对应关系（此处仅显示前10条），已存为字典（map_gene），右图为我们需要去匹配的gene名称，如何根据基因名称给出对应的编号？      2. 解决方案 2.1 定义变量 首先，我们定义一个空的list来存储gene对应的编号，且因部分gene在字典map_gene中不存在，故需记录可匹配到的个数。 # 定义变量...
词典快速匹配方案
qq_25956141的博客
10-04 1620
介绍 对于构造了几百万上千万的集合中，快速查找对应的元素是一种常见的应用场景，因此本文将探讨一种如何在一个大集合中快速查找对应元素的方法。 查找方案 哈希查找和字典树是两种高性能的查找方法。其中字典树使用最长前缀匹配法，其查找速度非常快，但由于更新时需要调整整个树，导致其更新速度较慢，因此字典树不适用于动态集合。而哈希查找解决了更新速度慢的问题，因此本文主要介绍基于哈希查找的词典匹配方法。 本文将...
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
英文单词分割symspellpy库依赖词典
05-20
symspellpy是可以进行文本的纠错，也可以将连在一起的字母分割成若干个单词的。根据实践表示该文件还是比较好用的，该文件是它的字典库。具体使用可参考博客...
SAP常用单词中英文字典.xls
01-26
SAP常用单词中英文字典.xls
fenci.rar_匹配字典_最大匹配 分词
09-23
正向最大匹配算法分词，采用容器储存字典可提高一定的效率。
Java实现 LeetCode 524 通过删除字母匹配到字典里最长单词（又是一道语文题）
12-21
524. 通过删除字母匹配到字典里最长单词 给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。...
shujujiegou.rar_单词基数排序_字典序
09-20
试设计一个将一组英文单词按字典序排列的基数排序算法。设单词均由小写字母或空格构成，最长的单词有MaxLen个字母
sqlserver 字符串分割、包含、匹配
05-11
2、按指定符号分割字符串，返回“分割后指定索引的第几个元素”的值，象数组一样方便 3、检查一个元素是否在数组中，返回1或0 4、检查一个元素是否与数组中的相匹配，并返回相匹配的数组的值。参数值为0表示全模糊...
Dic.zip_Dic.txt_dic_匹配字典
09-19
采用java编程的，基于指定txt字典的最大正向匹配
五位数单词域名字典
11-19
相信想注册好域名的人都需要域名字典，此字典收集了5个字母位数的单词。希望对你有用！
VC++实现在线查单词的远程字典服务.rar
03-15
VC++实现在线查单词的远程字典服务源代码
python实现快速匹配_python – 最快的字典匹配
weixin_39760389的博客
12-05 1253
我将不得不在Python中执行类似拼写检查的操作,如下所示：我有一个巨大的单词列表(让我们称之为词典).我现在给了一些文本(我们称之为样本).我必须在词典中搜索每个样本单词.如果我找不到它,那个样本字就是错误.简而言之 – 一个蛮力拼写检查器.但是,对每个样本字线性搜索词典必然会很慢.有什么更好的方法呢？复杂因素是样本和词典都不是英文的.它是一种语言而不是26个字符,可以有超过300个 – 以Un...
匹配字典 dict python3
小沙粒看未来
12-27 312
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 184
现在有两个字典，想要根据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 268
为什么80%的码农都做不了架构师？>>> ...
Python实现中文最大逆向匹配分词算法
最新发布
03-26
最大逆向匹配法是一种基于规则的分词方法，它以最大方式得到一个词典中最长的词作为匹配结果。本文将介绍如何使用Python实现中文最大逆向匹配分词算法。 1. 实现过程 1.1 读取字典 首先，我们需要准备一个字典文件以供分词使用。字典文件的每一行都是一个单词。在读取字典文件时，我们可以使用Python中的open函数和readlines函数。 dictionary = [] with open('dictionary.txt', encoding='UTF-8') as file: for line in file: dictionary.append(line.strip()) 1.2 最大逆向匹配 在最大逆向匹配算法中，我们需要先设定一个最大匹配长度max_len，以此来划定匹配范围。接下来，从右往左选择一个长度为max_len的子串，然后从字典中寻找与该子串匹配的最长词语。如果找到了匹配词，便将该词作为分割符号，并重新开始匹配。如果没有找到匹配词，则将匹配长度缩小一个字，重新匹配。 我们可以按照如下的方式实现最大逆向匹配算法： def reverse_max_match(sentence, dictionary, max_len): words = [] # 保存匹配结果 while sentence: # 只要有词未匹配完 for i in range(max_len, 0, -1): # 从最大长度开始找 if len(sentence) >= i: # 要保证有i个字符 if sentence[-i:] in dictionary: # 如果找到了词 words.append(sentence[-i:]) # 保存该词 sentence = sentence[:-i] # 截掉已匹配的词 break # 重新开始新的匹配 else: # 没有找到匹配的词 words.append(sentence[-1]) # 直接将该词作为分割符号 sentence = sentence[:-1] # 截掉已匹配的字符 return ' '.join(reversed(words)) # 因为是逆向匹配，所以要倒序排列 1.3 测试 最后，我们可以编写一个测试函数来测试分词算法的效果： def test(dictionary_file, sentence, max_len=5): dictionary = [] with open(dictionary_file, encoding='UTF-8') as file: for line in file: dictionary.append(line.strip()) result = reverse_max_match(sentence, dictionary, max_len) print('分词结果：', result) test('dictionary.txt', '我来到南京市长江大桥。') # 分词结果： 我 来到 南京市 长江大桥 。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值