題目連結：https://leetcode.com/problems/word-break/

要求給字串進行切分（break）是的得到的單詞都在字典中。

思路一：首先想到的暴力解法：在每個可能的位置將字串切分為兩部分，然後檢查這兩部分是否都存在於字串中，如果某部分字串不存在，則將此字串繼續進行切分，直到存在或者長度為1為止，這是個極其暴力的演算法，存在大量重複操作，程式碼如下：

class Solution {
    
    public static HashSet<String> hs;
    
    public boolean wordBreak(String s, List<String> wordDict) {
        
        hs=new HashSet<String>();
        Iterator<String> iter=wordDict.iterator();
        while(iter.hasNext())
            hs.add(iter.next());
        return recursive(s);
        
    }
    
    public static boolean recursive(String s)
    {
        if(hs.contains(s))
            return true;
        String s1=null;
        String s2=null;
        boolean isbreak=false;
        for(int i=0;i<=s.length()-2;i++)
        {
            s1=s.substring(0,i+1);
            s2=s.substring(i+1,s.length());
            isbreak =isbreak || (recursive(s1) && recursive(s2));
        }
        return isbreak;
    }
}
 

演算法複雜度高達O（2^n），自然會想到用動態規劃來講中間結果快取下來，於是想到用二維陣列來儲存列舉的子字串的

然後又想了一個稍微簡化的解法：

圖示如下：

"aaaaa"
["aaaa","aa"]

class Solution {
    
    public static HashSet<String> hs;
    
    public static boolean[][] memo;

    public static int n;
    
    public static boolean flag;
    
    public boolean wordBreak(String s, List<String> wordDict) {
        
        flag=false;
        n=s.length();
        memo=new boolean[n][n];
        Iterator<String> iter=wordDict.iterator();
        hs=new HashSet<>();
        while(iter.hasNext())
            hs.add(iter.next());
        for(int i=0;i<s.length();i++)
        {
            for(int j=i;j<s.length();j++)
            {
                String st=s.substring(i,j+1);
                if(hs.contains(st))
                    memo[i][j]=true;
            }
        }
        recursive(0);

        return memo[0][n-1];
    }
    
    public static void recursive(int j)
    {
        if(j>=n)
        {
            return;
        }
        for(int i=j;i<n;i++)
        {
            if(!flag && memo[j][i])
            {
                memo[0][i]=true;
                if(i==n-1)
                    flag=true;
                recursive(i+1);
            }
        }
    }
}
 

這個解法也TLE了，我根據TLE的測試用例發現還是列舉子字串這一步太消耗時間了，並且遇到連續相同的字母組成的字串時，遞迴那一步時間複雜度也較高，因為我將子字串作為動態規劃的單元記錄下來，然後通過相鄰關係拼接進行動態規劃，所以可以考慮將目標字串的字首串是否可以break在字典中作為動態規劃的單元。程式碼如下：

class Solution {

    
   public boolean wordBreak(String s, List<String> wordList)
   {
       if (s == null || s.length() == 0) 
           return false;
       int n = s.length();
       Set<String> set = new HashSet<>();
       for (String word : wordList) 
           set.add(word);
 
       boolean[] dp = new boolean[n];
       for (int i = 0; i < n; i++)  //外迴圈是填寫dp陣列的過程
       {
           for (int j = 0; j <= i; j++) //內迴圈是找符合條件的字首和存在於字典中的子字串（字首串與該子字串組成當前結尾於i位置的字首串）
           {
               String sub = s.substring(j, i + 1);
               if (set.contains(sub) && (j == 0 || dp[j - 1]))
               {
                   dp[i] = true;
                   break;
               }
           }
       }
       return dp[n - 1];
   }
}

這條題目解的過程真艱辛，不過動態規劃一般是基於暴力遞迴搜尋來優化的，只是優化的角度需要精緻的思考。