Question

我遇到了我的家庭作业，有人帮忙，请...

这是任务：查找字符串的所有可能分区到某些字典的单词

以下是我试图这样做的方法：我使用动态编程概念来填充矩阵，然后我就不知道如何从中检索数据

-- Task5_2
retrieve :: [[Int]] -> [String] -> Int -> Int -> Int -> [[String]]
retrieve matrix dict i j size
    | i >= size || j >= size = []
    | index /= 0 = [(dict !! index)]:(retrieve matrix dict (i + sizeOfWord) (i + sizeOfWord) size) ++ retrieve matrix dict i (next matrix i j) size
    where index = (matrix !! i !! j) - 1; sizeOfWord = length (dict !! index)


next matrix i j
    | j >= (length matrix) = j
    | matrix !! i !! j > 0 = j
    | otherwise = next matrix i (j + 1)

getPartitionMatrix :: String -> [String] -> [[Int]]
getPartitionMatrix text dict = [[ indiceOfWord (getWord text i j) dict 1  | j <- [1..(length text)]] | i <- [1..(length text)]]

--------------------------
getWord :: String -> Int -> Int -> String
getWord text from to = map fst $ filter (\a -> (snd a) >= from && (snd a) <= to) $ zip text [1..]


indiceOfWord :: String -> [String] -> Int -> Int
indiceOfWord _ [] _ = 0
indiceOfWord word (x:xs) n
    | word == x  = n
    | otherwise = indiceOfWord word xs (n + 1)


-- TESTS
dictionary = ["la", "a", "laa", "l"]
string = "laa"
matr = getPartitionMatrix string dictionary
test = retrieve matr dictionary 0 0 (length string)

Answer 1

这是一个符合您要求的代码。它不像你的解决方案那样工作，但是如果（并且只有当）我们的字典查找被改进以使用尝试是合理的，它应该工作得快。因为我认为它可能比你的解决方案快一点：

module Partitions (partitions) where
import Data.Array
import Data.List

data Branches a = Empty | B [([a],Branches a)] deriving (Show)

isEmpty Empty = True
isEmpty _     = False

flatten :: Branches a -> [ [ [a] ] ]
flatten Empty  = []
flatten (B []) = [[]]
flatten (B ps) = concatMap (\(word, bs) -> ...) ps

type Dictionary a = [[a]]

partitions :: (Ord a) => Dictionary a -> [a] -> [ [ [a] ] ]
partitions dict xs = flatten (parts ! 0)
    where 
      parts = listArray (0,length xs) $ zipWith (\i ys -> starting i ys) [0..] (tails xs)
      starting _ [] = B []
      starting i ys 
          | null words = ...
          | otherwise  = ...
          where 
            words = filter (`isPrefixOf` ys) $ dict
            go word = (word, parts ! (i + length word))

它的工作方式如下：在字符串的每个位置，它搜索字典中从那里开始的所有可能的单词并评估为Branches，这是一个死胡同（Empty）或者一个单词对和一系列可能延续的列表，丢弃那些无法继续的单词。

动态编程进入图片以记录从惰性数组中的给定索引开始的每种可能性。请注意，结是绑定的：我们使用parts计算starting，parts使用starting来查找可能来自给定索引的哪些延续。这只能起作用，因为我们只在一个starting计算后查找索引，而parts不使用{{1}}作为最后一个索引。

从此Branches数据类型检索分区列表类似于树中所有路径的列表。

编辑：我删除了解决方案的一些关键部分，以便让提问者自己搜索。虽然这不应该太难以完成一些思考。我可能会稍后用稍微清理过的版本把它们放回去。

从Matrix中检索字符串

1 个答案: