leetcode第11题（word-break-ii）

最新推荐文章于 2024-11-19 23:58:49 发布

原创最新推荐文章于 2024-11-19 23:58:49 发布 · 262 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#递归

牛客网（leetcode）专栏收录该内容

47 篇文章

订阅专栏

本文介绍了一种用于将给定字符串切割成合法字典单词组合的算法。该算法采用递归方式，利用哈希映射存储中间结果以提高效率，解决了字符串切割问题。示例中使用了catsanddog作为输入，展示了如何找到所有可能的有效句子。

题目：

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 ="catsanddog",
dict =["cat", "cats", "and", "sand", "dog"].

A solution is["cats and dog", "cat sand dog"].

思路：将字符串切割为两部分左边s1和右边s2，如果s1包含在字典中，则递归计算s2切割生成的字符串集合，并将s1和s2返回的结果并和。

* s2可能无法切割，我们让其返回一个空的ArrayList。

* s为空串是我们规定返回包含一个“”的ArrayList.

* 仅仅递归会超时，我们用一个map记录字符串对应的结果。

注意：以上思路写出来答案是对的，但是跟测试用例的顺序不对，因而不通过。

代码如下：

import java.util.*;
public class Solution {
    public  ArrayList<String> wordBreak(String s, Set<String> dict) {
        HashMap<String, List<String>> map = new HashMap<String, List<String>>();
        return dfs(s, dict, map);

    }

    public  ArrayList<String> dfs(String s, Set<String> dict, HashMap<String, List<String>> map) {
        if (map.containsKey(s))
            return (ArrayList<String>) map.get(s);

        ArrayList<String> lists = new ArrayList();
        if (s.equals(""))
            lists.add("");
        else {
            int len = s.length();
            for (int i = 1; i <= len; i++) {
                String sub = s.substring(0, i);
                if (dict.contains(sub)) {
                    ArrayList t = dfs(s.substring(i, len), dict, map);
                    if (t.size() == 0) {
                        continue;
                    }
                    else {
                        for (int j = 0; j < t.size(); j++) {
                            StringBuilder sb = new StringBuilder();
                            sb.append(sub).append(" ").append(t.get(j));
                            lists.add(sb.toString().trim());

                        }
                    }
                }
            }
        }
        map.put(s, lists);
        return lists;
    }
}

编译通过的代码

port java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class Solution {
    public  ArrayList<String> wordBreak(String s, Set<String> dict) {
        ArrayList<String> lists = new ArrayList<String>();
        ArrayList<String> strings = new ArrayList<String>();
        int len = s.length();
        dfs(s,len,dict,lists,strings);
        return lists;

    }

    public  void dfs(String s,int len,Set<String> dict, ArrayList<String> lists,ArrayList<String> strings) {
        if(len<=0){
            int size = strings.size()-1;
            StringBuilder sb = new StringBuilder();
            for(;size>=0;size--){
                sb.append(strings.get(size));
                if(size!=0)
                    sb.append(" ");
            }
            lists.add(sb.toString());
        }
        for(int k = len-1;k>=0;k--){
            if(dict.contains(s.substring(k,len))){
                strings.add(s.substring(k,len));
                dfs(s,k,dict,lists,strings);
                strings.remove(strings.size()-1);
            }
        }

    }
}