LeetCode #139. Word Break C#

 

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given s = "leetcode", dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

 

Solution:

Need to use DP because derictly loop through the string may not return the correct answer.

Test case: s="aaaaaaa", dict = ["aaa", "aaaa"]

Two solutions:

First Dynamic programming:

dp[0] = true;// always true, because empty string can always add space to it.

dp[1] = dp[0]&&dict.Contains(s.Substring(0, 1);

dp[2] =( dp[1]&&dict.Contains(s.Substring(1,1))) ||(dp[0]&& dict.Contains(s.Substring(0,2)));

so need to loop through dp[j]&&wordDict.Contains(s.Substring(j,i-j)) untill dp[i] is true where j from 0 to i;

public class Solution {
    public bool WordBreak(string s, ISet<string> wordDict)
        {
            ISet<int> set = new HashSet<int>();
            if(string.IsNullOrEmpty(s))
            {
                return true;
            }
            int l = s.Length;
            bool[] dp = new bool[l+1];
            dp[0] = true;
            for(int i=1; i<l+1; i++)
            {
                for(int j=0; j<i; j++)
                {
                    dp[i]=dp[j]&&wordDict.Contains(s.Substring(j,i-j));
                    if(dp[i])
                    {
                        break;
                    }
                }
            }
            return dp[l];
        }
       
}

Second DFS:

 

Use recursion in Dfs to mark the indexes those already looped through and returned false;

 

public class Solution {
    public bool WordBreak(string s, ISet<string> wordDict)
        {
            ISet<int> set = new HashSet<int>();
            return Dfs(s, 0, wordDict, set);

        }
        private bool Dfs(string s, int index, ISet<string> dict, ISet<int> set)
        {
            // base case
            if (index == s.Length) return true;
            // check memory
            if (set.Contains(index)) return false;
            // recursion
            for (int i = index + 1; i <= s.Length; i++)
            {
                String t = s.Substring(index, i-index);
                if (dict.Contains(t))
                    if (Dfs(s, i, dict, set))
                        return true;
                    else
                        set.Add(i);
            }
            set.Add(index);
            return false;
        }
}