140. 单词拆分 II

给定一个非空字符串 s 和一个包含非空单词列表的字典
wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。 说明：
分隔时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。 来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-break-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

char **ret = NULL;
int retSize = 0;
bool *dp = NULL;
char *str = NULL;
//num: 空格数， pre:当前字符开始的位置, slen:字符串s的长度 
void backtrack(char *s, char ** wordDict, int wordDictSize, int num, int pre, int slen)
{
    if(pre == slen)
    {
        char* tmp = (char*)malloc(sizeof(char) * (num + slen)); //字符长度为空格数+字符长度+结束符
        memcpy(tmp, str, sizeof(char) * (num - 1 + slen));
        tmp[num - 1 + slen] = '\0';
        ret[retSize++] = tmp;
        return;
    }

    for(int i = pre; i < slen; i++)
    {
        
        if(!dp[i+1])
        {
            continue;
        }

        bool flag = false;
        for(int j = 0; j < wordDictSize; j++) //遍历字典看是否存在字符串
        {
            int len = strlen(wordDict[j]);
            if(i - pre + 1 == len && strncmp(&s[pre], wordDict[j], len) == 0)
            {
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            continue;
        }

        memcpy(&str[pre+num], &s[pre], sizeof(char) * (i - pre + 1));
        str[i+1+num] = ' ';
        backtrack(s, wordDict, wordDictSize, num+1, i+1, slen);
        memset(&str[pre+num], 0, sizeof(char) * (i - pre + 2));

    }

}
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
char ** wordBreak(char * s, char ** wordDict, int wordDictSize, int* returnSize){
    int slen = strlen(s) + 1;
    dp = (bool*)malloc(sizeof(bool) * slen);
    memset(dp, false, sizeof(bool) * slen);
    dp[0] = true;

    for(int i = 1; i < slen; i++) //动态规划得到dp[i]，判断前i个字符是否在字典中
    {
        for(int j = 0; j < wordDictSize; j++)
        {
            int len = strlen(wordDict[j]);
            int k = i - len;
            if(k < 0)
            {
                continue;
            }

            dp[i] = (dp[k] && !strncmp(&s[k], wordDict[j], len)) || dp[i];
            if(dp[i])
            {
                break;
            }
        }

    }
    retSize = 0;
    ret = (char**)malloc(sizeof(char*) * 500);
    str = (char*)malloc(sizeof(char) * (slen*2));
    memset(str, 0, sizeof(char) * (slen*2));

    backtrack(s, wordDict, wordDictSize, 0, 0, slen-1);
    *returnSize = retSize;
    return ret;
}

思路：动态规划+回溯算法
使用动态规划判断前i个字符是否在字典中，然后使用回溯算法遍历所有的可能性