Skip to content

17.13. Re-Space

Description

Oh, no! You have accidentally removed all spaces, punctuation, and capitalization in a lengthy document. A sentence like "I reset the computer. It still didn't boot!" became "iresetthecomputeritstilldidntboot''. You'll deal with the punctuation and capi­talization later; right now you need to re-insert the spaces. Most of the words are in a dictionary but a few are not. Given a dictionary (a list of strings) and the document (a string), design an algorithm to unconcatenate the document in a way that minimizes the number of unrecognized characters. Return the number of unrecognized characters.

Note: This problem is slightly different from the original one in the book.

 

Example: 

Input: 

dictionary = ["looked","just","like","her","brother"]

sentence = "jesslookedjustliketimherbrother"

Output:  7

Explanation:  After unconcatenating, we got "jess looked just like tim her brother", which containing 7 unrecognized characters.

Note:

  • 0 <= len(sentence) <= 1000
  • The total number of characters in dictionary is less than or equal to 150000.
  • There are only lowercase letters in dictionary and sentence.

Solutions

Solution 1

Thinking

Insert spaces so unrecognized characters are minimized. All segmentations are exponential; \(O(n^2)\) interval checks fit the limits.

\(dp[i]\) is the fewest unknowns in the first \(i\) characters. The last piece is either one unknown or a dictionary word \(sentence[j:i]\) transferring from \(dp[j]\).

A set makes membership \(O(1)\). \(dp[0]=0\) fills up to \(n\). No trie is needed while \(n\) stays moderate.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Solution:
    def respace(self, dictionary: List[str], sentence: str) -> int:
        s = set(dictionary)
        n = len(sentence)
        dp = [0] * (n + 1)
        for i in range(1, n + 1):
            dp[i] = dp[i - 1] + 1
            for j in range(i):
                if sentence[j:i] in s:
                    dp[i] = min(dp[i], dp[j])
        return dp[-1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Solution {
    public int respace(String[] dictionary, String sentence) {
        Set<String> dict = new HashSet<>(Arrays.asList(dictionary));
        int n = sentence.length();
        int[] dp = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            dp[i] = dp[i - 1] + 1;
            for (int j = 0; j < i; ++j) {
                if (dict.contains(sentence.substring(j, i))) {
                    dp[i] = Math.min(dp[i], dp[j]);
                }
            }
        }
        return dp[n];
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Solution {
public:
    int respace(vector<string>& dictionary, string sentence) {
        unordered_set<string> s(dictionary.begin(), dictionary.end());
        int n = sentence.size();
        vector<int> dp(n + 1);
        for (int i = 1; i <= n; ++i) {
            dp[i] = dp[i - 1] + 1;
            for (int j = 0; j < i; ++j) {
                if (s.count(sentence.substr(j, i - j))) {
                    dp[i] = min(dp[i], dp[j]);
                }
            }
        }
        return dp[n];
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func respace(dictionary []string, sentence string) int {
    s := map[string]bool{}
    for _, v := range dictionary {
        s[v] = true
    }
    n := len(sentence)
    dp := make([]int, n+1)
    for i := 1; i <= n; i++ {
        dp[i] = dp[i-1] + 1
        for j := 0; j < i; j++ {
            if s[sentence[j:i]] {
                dp[i] = min(dp[i], dp[j])
            }
        }
    }
    return dp[n]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class TrieNode {
    var children: [TrieNode?] = Array(repeating: nil, count: 26)
    var isEndOfWord = false
}

class Trie {
    private let root = TrieNode()

    func insert(_ word: String) {
        var node = root
        for char in word {
            let index = Int(char.asciiValue! - Character("a").asciiValue!)
            if node.children[index] == nil {
                node.children[index] = TrieNode()
            }
            node = node.children[index]!
        }
        node.isEndOfWord = true
    }

    func search(_ sentence: Array<Character>, start: Int, end: Int) -> Bool {
        var node = root
        for i in start...end {
            let index = Int(sentence[i].asciiValue! - Character("a").asciiValue!)
            guard let nextNode = node.children[index] else {
                return false
            }
            node = nextNode
        }
        return node.isEndOfWord
    }
}

class Solution {
    func respace(_ dictionary: [String], _ sentence: String) -> Int {
        let n = sentence.count
        guard n > 0 else { return 0 }
        let trie = Trie()
        dictionary.forEach { trie.insert($0) }
        let chars = Array(sentence)
        var dp = Array(repeating: Int.max, count: n + 1)
        dp[0] = 0
        for i in 1...n {
            dp[i] = dp[i - 1] + 1
            for j in 0..<i {
                if trie.search(chars, start: j, end: i - 1) {
                    dp[i] = min(dp[i], dp[j])
                }
            }
        }
        return dp[n]
    }
}

Comments