diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
index e04cb173..3aa5ca0f 100644
--- a/problems/0139.单词拆分.md
+++ b/problems/0139.单词拆分.md
@@ -250,30 +250,34 @@ class Solution {
 
 // 回溯法+记忆化
 class Solution {
+    private Set<String> set;
+    private int[] memo;
     public boolean wordBreak(String s, List<String> wordDict) {
-        Set<String> wordDictSet = new HashSet(wordDict);
-        int[] memory = new int[s.length()];
-        return backTrack(s, wordDictSet, 0, memory);
+        memo = new int[s.length()];
+        set = new HashSet<>(wordDict);
+        return backtracking(s, 0);
     }
-    
-    public boolean backTrack(String s, Set<String> wordDictSet, int startIndex, int[] memory) {
-        // 结束条件
-        if (startIndex >= s.length()) {
+
+    public boolean backtracking(String s, int startIndex) {
+        // System.out.println(startIndex);
+        if (startIndex == s.length()) {
             return true;
         }
-        if (memory[startIndex] != 0) {
-            // 此处认为：memory[i] = 1 表示可以拼出i 及以后的字符子串， memory[i] = -1 表示不能
-            return memory[startIndex] == 1 ? true : false;
+        if (memo[startIndex] == -1) {
+            return false;
         }
-        for (int i = startIndex; i < s.length(); ++i) {
-            // 处理 递归 回溯       循环不变量：[startIndex, i + 1)
-            String word = s.substring(startIndex, i + 1);
-            if (wordDictSet.contains(word) && backTrack(s, wordDictSet, i + 1, memory)) {
-                memory[startIndex] = 1;
-                return true;
+
+        for (int i = startIndex; i < s.length(); i++) {
+            String sub = s.substring(startIndex, i + 1);
+	    // 拆分出来的单词无法匹配
+            if (!set.contains(sub)) {
+                continue;                
             }
+            boolean res = backtracking(s, i + 1);
+            if (res) return true;
         }
-        memory[startIndex] = -1;
+        // 这里是关键，找遍了startIndex~s.length()也没能完全匹配，标记从startIndex开始不能找到
+        memo[startIndex] = -1;
         return false;
     }
 }