每日一题算法:2020年6月25日 单词拆分 wordBreak

2020年6月25日 单词拆分 wordBreak

在这里插入图片描述

默认格式:

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {

    }
}

解题思路:

之前做过类似的题目,这道题的难点就在于如何区分字符有部分内容重复的情况。比如下面这样

dogsxxxxxxxx…,[dog,dogs,xxxx,xxxx,…] 当你读取到dog的时候,你无法确定应该选择dog或者dogs来作为拆分开的单词,所以为了考虑到所有的情况这里需要用遍历,去判断所有符合当前条件的单词。

这样就会产生两条分支,而分支之下还能产生新的分支,所以这种情况应该使用递归的方式。

最后,如果某一条分支得到的结果是错误的,那么应该结束当前分支,返回上一次开始分支的节点开始下一次分支,这种情况需要使用回溯的算法。

既然是用到了递归,那就写一下递归需要的那些参数和实现的功能。

传入参数:数组下标、字符数组、单词链表

(这里使用字符下标+数组的组合比创建一个新的字符串更节省时间和空间)

返回值:boolean

过程:

如何匹配字符串和单词也是一个难点。

新建一个链表,第一次比较第一个字符是否相等,如果相等从单词表中取出,形成一个新的链表

然后遍历该链表中的所有字母,如果和当前字母不相等了,直接在链表中删除

如果和当前字符相等,判断是否已经达到了该字符的结尾处,如果达到了,对剩下的数组进行递归,并且在递归结束后判断结果,如果没有成功,那么在链表中删除该字母。

递归结束:

循环直到链表为空时结束,如果链表已经空了但是没有找到正确的字母,直接返回false

如果一个字母匹配时,位置已经到达了字符数组的末尾,返回true。

代码实现:

实际上还是直接使用了字符串来进行计算,因为链表里的都是字符串,如果我一边用字符串计算一边用字符数组计算就会很奇怪。

public boolean wordBreak(String s, List<String> wordDict) {

        //如果数组已经为空
        if (s.equals(""))
            return true;

        List<String> matchWordDict=new LinkedList<>();

        //第一次循环,遍历这个单词数组,找出第一个字符匹配的单词
        for (int i=0;i<wordDict.size();i++){

            //如果第一个字符相等,并且长度必须小于s
            if (wordDict.get(i).charAt(0)==s.charAt(0)&&wordDict.get(i).length()<=s.length()){
                matchWordDict.add(wordDict.get(i));
            }
        }
       //在第一个字符匹配的单词数组中找到第二个字符匹配的单词 ,从第二个字符开始
        for (int i=1;matchWordDict.size()!=0;i++){

            List<String> nowList=new LinkedList<>();
            //遍历剩下的数组
            for (String now:matchWordDict){

                //字符匹配而且长度匹配
                if (i==now.length()-1&&now.charAt(i)==s.charAt(i)){

                    //截取这个新的字符串
                    String newS=s.substring(i+1);

                    if (wordBreak(newS,wordDict)){
                        return true;
                    }
                }
                //如果单词长度只有1
                else if (now.length()==1) {
                    //截取这个新的字符串
                    String newS=s.substring(1);

                    if (wordBreak(newS,wordDict)){
                        return true;
                    }
                }
                //剩下的情况就是长度还不够到达的情况,将其加入新的数组
                else if (now.charAt(i)==s.charAt(i))
                    nowList.add(now);
            }
            matchWordDict=nowList;
        }
        return false;
    }

在这里插入图片描述

那我就先对集合进行处理,删除掉哪些能够被集合中本身字母给替代的字母。

        for (String now:wordDict){
            List<String> nowList=new LinkedList<>(wordDict);
            nowList.remove(now);
            if (wordBreak(now, nowList)){
                wordDict=nowList;
            }
        }

emmm好像更复杂了。还是找其他的优化方式吧。

我发现我这个算法在保存有效单词的时候有很多的LinkedList的创建很浪费时间,思前想后决定使用HashSet来存整个单词集,这样在查找的时候还可以直接用hashcode去查找。

    public boolean wordBreak(String s, List<String> wordDict) {

        //如果数组已经为空
        if (s.equals(""))
            return true;

        for (String now:wordDict){
            //不出现数组溢出的必要条件,长度相等
            if (now.length()<=s.length()&&s.substring(0,now.length()).equals(now)){
                if(wordBreak(s.substring(now.length()), wordDict))
                    return true;
            }
        }
        return false;
    }

最终改版:

在这里插入图片描述

List<String> newWordDict=new ArrayList<>();
    public boolean wordBreak(String s, List<String> wordDict){

        newWordDict.addAll(wordDict);
        for (String now:wordDict){
            newWordDict.remove(now);

            //如果除了该单词以外,其他单词不能够组成该单词,则将其加回来
            if (!wordBreak2(now,newWordDict)){
                newWordDict.add(now);
            }

        }

        return wordBreak2(s,newWordDict );
    }


    public boolean wordBreak2(String s, List<String> wordDict) {

        //如果数组已经为空
        if (s.equals(""))
            return true;


        //遍历整个集合,看一看当前字符串的开头是否存在匹配的情况。
        for (String now:wordDict){
            //不出现数组溢出的必要条件,长度相等
            if (now.length()<=s.length()&&s.substring(0,now.length()).equals(now)){
//                System.out.println(s.substring(now.length()).length());
                if(wordBreak2(s.substring(now.length()), wordDict))
                    return true;
            }
        }
        return false;
    }

我认为我是钻进了思维的牛角尖了,还是看一下别人的解决方案吧。

精彩!!!

在这里插入图片描述

虽然不是什么很高端的算法,和我之前的做法几乎一模一样,但是通过一个简单的方案就解决了我这么长时间的困扰,用备忘录。

构建一个备忘录,记录某个节点时是否已经进行过遍历,如果已经遍历过了,那么当前这次的递归就没有做的必要了,因为结果必定是一样的,所以将其记录在备忘录中,在进行递归的过程中,查看备忘录,如果当前节点已经被判断过了,那么直接返回false.

    boolean[] bs;
    public boolean wordBreak(String s, List<String> wordDict) {

        //初始化备忘录
        if (bs==null){
            bs=new boolean[s.length()];
        }


        //如果数组已经为空
        if (s.equals(""))
            return true;

        //如果已经记录过该长度的字符串是无法通过的,直接返回false
        if (bs[s.length()-1]){
            return false;
        }

        //遍历整个集合,看一看当前字符串的开头是否存在匹配的情况。
        for (String now:wordDict){
            //不出现数组溢出的必要条件,长度相等
            if (now.length()<=s.length()&&s.substring(0,now.length()).equals(now)){

                if(wordBreak(s.substring(now.length()), wordDict)){

                    return true;
                }
            }
        }

        //到达这里说明该长度的字符串是错误的,记录下来
        bs[s.length()-1]=true;
        return false;
    }
©️2020 CSDN 皮肤主题: 游动-白 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值