leetcode139. 单词拆分

回溯算法，用一个哈希表记录当前的划分方法是否可以，由于相当于深度优先，
如果返回了，说明这种划分方法不行，标记下来防止重复访问

def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: bool
        """
        res = []
        ans = []
        vis = dict()           #用一个标记访问当前i是否访问过
        memo = [0]*(len(s)+1)
        def backtrack(index, s):
            if index in vis:              #组成s[:i]之后没办法组成完整单词，因为如果有办法已经返回True了所以不用考虑
                return False
            if index == len(s):
                return True
            for i in range(index + 1, len(s)+1):
                word = s[index:i]
                if word in wordDict:      #s[:i]可以组成
                    if backtrack(i, s):   #再判断s[i:]               
                        return True
                    vis[i] = False       #s[i:]这种划分组不成，所以标记为False
            return False
        return backtrack(0, s)

动态规划，枚举当前位置之前的所有起点
dp定义为以当前位置i为结尾子串的是否能被拆分
遍历整个字符串，转移方程就是当前i位置之前的所有的j, [j:i]是否能组成单词且j是否能被拆分

def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: bool
        """
        n = len(s)
        dp = [False]*(n+1)
        dic = set(wordDict)
        dp[0] = True
        for i in range(n+1):
            for j in range(i-1,-1,-1):
                sub = s[j:i]
                if sub in dic and dp[j]:
                    dp[i] = True
                    break
        return dp[n]