work break II

import java.util.List;//超时
import java.util.Set;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
public class Solution {
    private int dict_size_min=Integer.MAX_VALUE;
    private int dict_size_max=-1;
    private HashMap<String,Set<String>> hashMap=new HashMap();
    public List<String> wordBreak(String s, List<String> wordDict) {
        int start=0;
        int end=s.length();
        for(String str:wordDict)
        {
            if(str.length()<dict_size_min)
            {
                dict_size_min=str.length();
            }
            if(str.length()>dict_size_max)
            {
                dict_size_max=str.length();
            }
        }

        Set<String> sen=returnWords(s,wordDict,start,end);


        return new ArrayList<>(sen);

    }
    private Set<String> returnWords(String s,List<String> wordDict,int start,int end) {
        int strLen=end-start;
        String str=s.substring(start,end);
        Set<String> results=hashMap.get(str);
        if(results!=null)
        {
            return results;
        }

        Set<String> cur=new HashSet<>();
        if(strLen<=dict_size_max&&strLen>=dict_size_min)
        {

            String word=findWordInDict(str,wordDict);
            if(word!=null)
            {
                cur.add(word);
            }



        }

        if(strLen>dict_size_min)
        {

            for(int i=start+1;i<end;i++)
            {
                Set<String> f1=returnWords(s, wordDict, start, i);
                Set<String> f2=returnWords(s, wordDict, i, end);
                if(f1==null||f2==null)
                {
                    continue;
                }
                for(String str1:f1)
                {
                    for(String str2:f2)
                    {
                        cur.add(str1+" "+str2);
                    }
                }

            }


        }
        hashMap.put(str,cur );
        return cur;

    }
    private String findWordInDict(String str,List<String> wordDict)
    {
        for(String word:wordDict)
        {
            if(str.equals(word))
            {
                return str;
            }
        }
        return null;
    }
}

考虑了很多重复情况：
s=”abc”
dict={“a”,”b”,”c”}
f(0,3)=f(0,1)*f(1,3)+f(0,2)*f(2,3)+f(0,3)*f(3,3)
结果只有a b c
但是三个子问题都会得出这个值，重复计算。

应该以找出s为出发点。

import java.util.List;
import java.util.Set;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;


public class Solution {
    private int dict_size_min = Integer.MAX_VALUE;
    private int dict_size_max = -1;
    private HashMap<String, Set<String>> hashMap = new HashMap();

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

        for (String str : wordDict) {
            if (str.length() < dict_size_min) {
                dict_size_min = str.length();
            }
            if (str.length() > dict_size_max) {
                dict_size_max = str.length();
            }
        }

        Set<String> senSet=returnWords(s, wordDict, 0);


        return  new ArrayList<>(senSet);

    }

    private Set<String> returnWords(String s, List<String> wordDict, int start) {
        if (start == s.length()) {
            Set<String> set = new HashSet<>();
            set.add("");
            return set;
        }

        String str = s.substring(start, s.length());
        if (hashMap.containsKey(str)) {
            return hashMap.get(str);
        }


        HashSet<String> hashSet = new HashSet<>();

        for (int j = start; j <= start + dict_size_max && j <= s.length(); j++) {
            if (j - start < dict_size_min) {
                continue;
            }

            String lookupStr = s.substring(start, j);

            String word = findWordInDict(lookupStr, wordDict);
            if (word != null) {
                Set<String> remainWords = returnWords(s, wordDict, j);

                for (String remain : remainWords) {
                    if (remain.equals("")) {
                        hashSet.add(word);
                    } else {
                        hashSet.add(word + " " + remain);
                    }


                }


            }
        }
        hashMap.put(str, hashSet);
        return hashSet;


    }

    private String findWordInDict(String str, List<String> wordDict) {
        for (String word : wordDict) {
            if (str.equals(word)) {
                return str;
            }
        }
        return null;
    }
}