Recurrence relation for DP?

Question

Suppose you have a dictionary that contains valid words.

Given an input string with all spaces removed, determine whether the string is composed of valid words or not.

You can assume the dictionary is a hashtable that provides O(1) lookup.

Please give a recurrence relation for this. I found this question in a book , but the book gives no answer?

Are you having trouble coming up with the algorithm or finding a recurrence relation for the algorithm? — Mark Peters, Apr 06 '11 at 18:35
if you're just having trouble with finding the recurrence relation, why don't you describe the algorithm in your post? — Mark Peters, Apr 06 '11 at 19:16

dfb · Accepted Answer · 2011-04-06T20:33:31.943

2

IsWordValid(S) = for word in dict:
                    if S.startsWith(word) and IsWordValid(S[word.length:])
                          return true
                 return false
IsWordValid(null) = true

edited Apr 06 '11 at 20:33

answered Apr 06 '11 at 19:00

dfb

13,133
2
31
52

Is this a Recurrence relation. – Programmer Apr 06 '11 at 19:02
a dynamic programming recurrence relation is generally top down. This one is bottom up. I dont know how it appears so – Programmer Apr 06 '11 at 19:14
@spinning_plate I don't think this is correct. You want to return _true_ if **any** word in the dictionary that is a prefix leads to a valid segmentation. You're returning as soon as you find a prefix, regardless of if it is an answer or not. – abeln Apr 06 '11 at 19:57
@Programmer - how is it bottom up? It starts from the full string and decomposes it in to subproblems? – dfb Apr 06 '11 at 20:35

score 0 · Answer 2 · answered Apr 06 '11 at 18:41

Here is a code in Mathematica I started to develop for a recent code golf.
It is a minimal matching, non greedy, recursive algorithm. That means that the sentence "the pen is mighter than the sword" (without spaces) returns {"the pen is might er than the sword} :)

findAll[s_] :=
  Module[{a = s, b = "", c, sy = "="},
  While[
   StringLength[a] != 0,
   j = "";
   While[(c = findFirst[a]) == {} && StringLength[a] != 0,
    j = j <> StringTake[a, 1];
    sy = "~";
    a = StringDrop[a, 1];
   ];
   b = b <> " " <> j ;
   If[c != {},
    b = b <> " " <> c[[1]];
    a = StringDrop[a, StringLength[c[[1]]]];
   ];
  ];
   Return[{StringTrim[StringReplace[b, "  " -> " "]], sy}];
]

findFirst[s_] :=
  If[s != "" && (c = DictionaryLookup[s]) == {}, 
   findFirst[StringDrop[s, -1]], Return[c]];

Sample Input

ss = {"twodreamstop", 
      "onebackstop", 
      "butterfingers", 
      "dependentrelationship", 
      "payperiodmatchcode", 
      "labordistributioncodedesc", 
      "benefitcalcrulecodedesc", 
      "psaddresstype", 
      "ageconrolnoticeperiod",
      "month05", 
      "as_benefits", 
      "fname"}

Output

 twodreamstop              = two dreams top
 onebackstop               = one backstop
 butterfingers             = butterfingers
 dependentrelationship     = dependent relationship
 payperiodmatchcode        = pay period match code
 labordistributioncodedesc ~ labor distribution coded es c
 benefitcalcrulecodedesc   ~ benefit c a lc rule coded es c
 psaddresstype             ~ p sad dress type
 ageconrolnoticeperiod     ~ age con rol notice period
 month05                   ~ month 05
 as_benefits               ~ as _ benefits
 fname                     ~ f name

HTH

Recurrence relation for DP?

2 Answers2