Как найти список возможных слов из буквенной матрицы [Boggle Solver]

В последнее время я играю в игру на своем iPhone под названием Scramble. Некоторые из вас могут знать эту игру как Boggle. По сути, когда игра начинается, вы получаете матрицу букв примерно так:

F X I E
A M L O
E W B X
A S T U

Цель игры - найти как можно больше слов, которые можно составить, объединив буквы. Вы можете начать с любой буквы, и все буквы, которые ее окружают, являются честной игрой, а затем, как только вы перейдете к следующей букве, все буквы, которые окружают эту букву, являются честной игрой, за исключением любых ранее использованных букв . Таким образом , в приведенном выше сетки, например, я мог придумать слова LOB, TUX, SEA, FAMEи т.д. Слова должны быть не менее 3 -х символов и не более символов NxN, который будет 16 в этой игре , но может изменяться в некоторых реализациях , Хотя эта игра веселая и затягивающая, я, видимо, не очень хорош в ней, и я хотел немного обмануть, создав программу, которая дала бы мне наилучшие слова (чем длиннее слово, тем больше очков вы получаете).

Образец Boggle
(источник: boggled.org )

Я, к сожалению, не очень хорош с алгоритмами или их эффективностью и так далее. Моя первая попытка использует словарь , такие как этот (~ 2.3MB) и делает линейный поиск пытается соответствовать комбинации с словарных статей. Это занимает очень много времени, чтобы найти возможные слова, и так как вы получаете только 2 минуты за раунд, это просто не подходит.

Мне интересно посмотреть, могут ли какие-либо Stackoverflowers предложить более эффективные решения. Я в основном ищу решения, использующие Big 3 Ps: Python, PHP и Perl, хотя что-нибудь с Java или C ++ тоже круто, так как скорость важна.

ТЕКУЩИЕ РЕШЕНИЯ :

  • Адам Розенфилд, Питон, ~ 20 лет
  • Джон Фухи, Питон, ~ 3 с
  • Кент Фредрик, Perl, ~ 1с
  • Дариус Бэкон, Питон, ~ 1с
  • rvarcher, VB.NET (прямая ссылка) , ~ 1с
  • Паоло Бергантино, PHP (прямая ссылка) , ~ 5 с (~ 2 с локально)
14.04.2009 02:11:33
ЗАПРОСЫ МОУРА
Kent Fredric 14.04.2009 16:14:28
Что касается времени: в моем решении практически все время тратится на создание дерева. Как только дерево построено, его можно использовать много раз. Если бы решалась только одна загадка, было бы эффективнее использовать более простую структуру данных (например, набор всех слов и всех префиксов).
Adam Rosenfield 15.04.2009 02:02:23
Кроме того, у Адама есть больший словарь, о чем свидетельствует количество более длинных слов, которые использует его решение. Все они должны быть проверены на основе общего словаря.
Rich Bradshaw 2.07.2009 16:08:59
Я думаю, никто не играет много Боггл? «Qu» - это одна «буква», и я не уверен, сколько из решений уловили эту мелочь. Похоже, что некоторые из них позволят вам использовать «u» независимо от других проблем.
Qsario 29.07.2012 00:45:23
У меня недавно было это как вопрос интервью, и я застрял в деталях. Я рассматривал это как проблему с графиком, и это нормально, но решения здесь занимают гораздо меньше места. Я сейчас пишу свое собственное решение. Молодцы всем, кто внес свой вклад!
Peter Friend 9.03.2013 03:14:04
30 ОТВЕТОВ
РЕШЕНИЕ

Мой ответ работает так же, как и другие, но я опубликую его, потому что он выглядит немного быстрее, чем другие решения Python, от настройки словаря быстрее. (Я проверил это по решению Джона Фухи.) После настройки время, чтобы решить, уменьшается в шуме.

grid = "fxie amlo ewbx astu".split()
nrows, ncols = len(grid), len(grid[0])

# A dictionary word that could be a solution must use only the grid's
# letters and have length >= 3. (With a case-insensitive match.)
import re
alphabet = ''.join(set(''.join(grid)))
bogglable = re.compile('[' + alphabet + ']{3,}$', re.I).match

words = set(word.rstrip('\n') for word in open('words') if bogglable(word))
prefixes = set(word[:i] for word in words
               for i in range(2, len(word)+1))

def solve():
    for y, row in enumerate(grid):
        for x, letter in enumerate(row):
            for result in extending(letter, ((x, y),)):
                yield result

def extending(prefix, path):
    if prefix in words:
        yield (prefix, path)
    for (nx, ny) in neighbors(path[-1]):
        if (nx, ny) not in path:
            prefix1 = prefix + grid[ny][nx]
            if prefix1 in prefixes:
                for result in extending(prefix1, path + ((nx, ny),)):
                    yield result

def neighbors((x, y)):
    for nx in range(max(0, x-1), min(x+2, ncols)):
        for ny in range(max(0, y-1), min(y+2, nrows)):
            yield (nx, ny)

Пример использования:

# Print a maximal-length word and its path:
print max(solve(), key=lambda (word, path): len(word))

Изменить: отфильтровать слова длиной менее 3 букв.

Редактировать 2: мне было любопытно, почему Perl-решение Кента Фредрика было быстрее; оказывается, что вместо набора символов используется сопоставление с регулярным выражением. То же самое в Python примерно вдвое увеличивает скорость.

142
11.11.2012 16:55:53
Программа только дает мне 1 слово. Как так?
Paolo Bergantino 15.04.2009 02:18:57
Я не хотел тонуть в выходных. Смотрите комментарий внизу.
Darius Bacon 15.04.2009 02:38:56
Или получите все слова без путей: print '' .join (отсортировано (установлено (слово (слово, путь) в execute ())))
Darius Bacon 15.04.2009 02:40:10
Большая часть времени уходит только на разбор словаря. Я предварительно проанализировал это в файле «wordlines.py», который представляет собой просто список, в котором каждое слово является элементом. Поскольку это файл .py, он превратится в файл .pyc. Тогда я делаю импорт этого вместо read (). Splitlines (). С этим, на моей коробке, я решаю это примерно за одну десятую секунды.
Sean Reifschneider 6.11.2010 23:00:06
@shellscape, это код Python 2. В Python 3 упала возможность деконструировать аргументы вроде def neighbors((x, y))(бессмысленно, насколько я вижу). Также требуются скобки вокруг аргумента print.
Darius Bacon 15.02.2013 15:33:46

Сначала прочитайте, как один из разработчиков языка C # решил связанную проблему: http://blogs.msdn.com/ericlippert/archive/2009/02/04/a-nasality-talisman-for-the-sultana-analyst.aspx ,

Как и он, вы можете начать со словаря и канонизировать слова, создав словарь из массива букв, отсортированных по алфавиту, в список слов, которые можно записать по этим буквам.

Затем начните создавать возможные слова на доске и искать их. Я подозреваю, что это продвинет вас довольно далеко, но, безусловно, есть и другие приемы, которые могут ускорить процесс.

4
14.04.2009 02:22:17

Ваш алгоритм поиска постоянно уменьшает список слов по мере того, как поиск продолжается?

Например, в приведенном выше поиске есть только 13 букв, с которых ваши слова могут начинаться (эффективно уменьшая вдвое больше начальных букв).

Поскольку вы добавляете больше буквенных перестановок, это приведет к дальнейшему уменьшению доступных наборов слов, уменьшая необходимый поиск.

Я бы начал там.

4
14.04.2009 02:16:28

Самое быстрое решение, которое вы получите, вероятно, будет включать хранение вашего словаря в три раза . Затем создайте очередь триплетов ( x , y , s ), где каждый элемент в очереди соответствует префиксу s слова, которое может быть записано в сетке и заканчивающемуся в местоположении ( x , y ). Инициализируйте очередь с N x N элементами (где N - размер вашей сетки), по одному элементу для каждого квадрата в сетке. Затем алгоритм работает следующим образом:

Пока очередь не пуста:
  Снять тройку (x, y, s)
  Для каждого квадрата (x ', y') с буквой c рядом с (x, y):
    Если s + c является словом, выведите s + c
    Если s + c является префиксом слова, вставьте (x ', y', s + c) в очередь

Если вы храните свой словарь в дереве, проверка, является ли s + c словом или префиксом слова, может выполняться в постоянное время (при условии, что вы также сохраняете некоторые дополнительные метаданные в каждом элементе очереди, такие как указатель на текущий узел в три), поэтому время выполнения этого алгоритма составляет O (количество слов, которые могут быть написаны).

[Edit] Вот реализация в Python, которую я только что написал:

#!/usr/bin/python

class TrieNode:
    def __init__(self, parent, value):
        self.parent = parent
        self.children = [None] * 26
        self.isWord = False
        if parent is not None:
            parent.children[ord(value) - 97] = self

def MakeTrie(dictfile):
    dict = open(dictfile)
    root = TrieNode(None, '')
    for word in dict:
        curNode = root
        for letter in word.lower():
            if 97 <= ord(letter) < 123:
                nextNode = curNode.children[ord(letter) - 97]
                if nextNode is None:
                    nextNode = TrieNode(curNode, letter)
                curNode = nextNode
        curNode.isWord = True
    return root

def BoggleWords(grid, dict):
    rows = len(grid)
    cols = len(grid[0])
    queue = []
    words = []
    for y in range(cols):
        for x in range(rows):
            c = grid[y][x]
            node = dict.children[ord(c) - 97]
            if node is not None:
                queue.append((x, y, c, node))
    while queue:
        x, y, s, node = queue[0]
        del queue[0]
        for dx, dy in ((1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1)):
            x2, y2 = x + dx, y + dy
            if 0 <= x2 < cols and 0 <= y2 < rows:
                s2 = s + grid[y2][x2]
                node2 = node.children[ord(grid[y2][x2]) - 97]
                if node2 is not None:
                    if node2.isWord:
                        words.append(s2)
                    queue.append((x2, y2, s2, node2))

    return words

Пример использования:

d = MakeTrie('/usr/share/dict/words')
print(BoggleWords(['fxie','amlo','ewbx','astu'], d))

Вывод:

['fa', 'xi', 'ie', 'io', 'el', 'am', 'ax', 'ae', 'aw', 'mi', 'ma', 'me', ' lo ',' li ',' oe ',' ox ',' em ',' ea ',' ea ',' es ',' wa ',' we ',' wa ',' bo ',' bu ' , 'as', 'aw', 'ae', 'st', 'se', 'sa', 'tu', 'ut', 'fam', 'fae', 'imi', 'eli', ' elm ',' elb ',' ami ',' ama ',' ame ',' aes ',' awl ',' awa ',' awe ',' awa ',' mix ',' mim ',' mil ' , 'mam', 'max', 'mae', 'maw', 'mew', 'mem', 'mes', 'lob', 'lox', 'lei ',' leo ',' lie ',' lim ',' oil ',' olm ',' ewe ',' eme ',' wax ',' waf ',' wae ',' waw ',' wem ' , 'wea', 'wea', 'was', 'waw', 'wae', 'bob', 'blo', 'bub', 'but', 'ast', 'ase', 'asa', ' awl ',' awa ',' awe ',' awa ',' aes ',' swa ',' swa ',' sew ',' sea ',' sea ',' saw ',' tux ',' tub ' , 'tut', 'twa', 'twa', 'tst', 'utu', 'fama', 'fame', 'ixil', 'imam', 'amli', 'amil', 'ambo', ' axil ',' axle ',' mimi ',' mima ',' mime ',' milo ','миля »,« mewl »,« mese »,« mesa »,« lolo »,« lobo »,« lima »,« lime »,« limb »,« lile »,« oime »,« oleo »,« olio » , «гобой», «оболь», «эмим», «эмиль», «восток», «легкость», «wame», «вава», «вава», «вейм», «запад», «везе», « wast ',' wase ',' wawa ',' wawa ',' boil ',' bolo ',' bole ',' bobo ',' blob ',' bleo ',' bubo ',' asem ',' stub ' , 'stut', 'swam', 'semi', 'seme', 'seam', 'seax', 'sasa', 'sawt', 'tutu', 'tuts', 'twae', 'twas', ' twae ',' ilima ',' amble ',' axile ', 'awest', 'mamie', 'mambo', 'maxim', 'mease', 'mesem', 'limax', 'limes', 'limbo', 'limbu', 'obole', 'emesa', ' embox »,« awest »,« swami »,« famble »,« mimble »,« maxima »,« embolo »,« embole »,« wamble »,« semese »,« semble »,« sawbwa »,« sawbwa » ]sawbwa ']sawbwa ']

Примечания: Эта программа не выводит однобуквенные слова или вообще не фильтрует по длине слова. Это легко добавить, но не имеет отношения к проблеме. Он также выводит некоторые слова несколько раз, если они могут быть написаны несколькими способами. Если данное слово может быть написано по-разному (наихудший случай: каждая буква в сетке одинакова (например, «A»), а слово типа «aaaaaaaaaa» есть в вашем словаре), тогда время выполнения станет ужасно экспоненциальным , Фильтрация дубликатов и сортировка тривиальны после завершения работы алгоритма.

116
14.04.2009 03:02:06
Ууу. Я рад, что кто-то подошел к тарелке. Хотя это работает, он не «запоминает» букву, которую он уже использовал, и предлагает слова, для которых требуется использовать одну и ту же букву дважды, что недопустимо. Как я идиот, как бы я исправить это?
Paolo Bergantino 14.04.2009 03:02:53
Правда, он не помнит, какие письма были посещены, но это не было указано в вашей спецификации =). Чтобы это исправить, вам нужно добавить в каждую базу данных список всех посещенных мест, а затем проверить этот список перед добавлением следующего символа.
Adam Rosenfield 14.04.2009 03:04:54
Нет, внутри BoggleWords (). Вместо того, чтобы хранить четверку (x, y, s, n), вы должны хранить квинтуплет (x, y, s, n, l), где l - это список посещенных (x, y) до сих пор. Затем вы проверяете каждое (x2, y2) на l и принимаете его, только если оно не на l. Затем вы добавляете его к новому l.
Adam Rosenfield 14.04.2009 03:15:31
Я тоже так делал, когда мне надоело играть в Scramble. Я думаю, что рекурсивное решение (DFS вместо BFS) более сексуально, поскольку вы можете просто сохранить набор активных ячеек (чтобы вы не посещали одну и ту же ячейку дважды). Гораздо аккуратнее, чем хранить кучу списков.
Justin Scheiner 30.06.2009 04:59:28
Разве это не должно попадать в бесконечный цикл? Я имею в виду, скажем, для (x,y)возможного последователя (x+1,y+1). Затем (x+1,y+1)выталкивается в очередь. Однако (x,y)тоже будет для вас последователем (x+1,y+1), не приведет ли это к бесконечному подпрыгиванию между ними?
SexyBeast 14.10.2012 21:31:15

Я должен был бы больше подумать о полном решении, но в качестве удобной оптимизации мне интересно, может быть, стоит предварительно рассчитать таблицу частот диграмм и триграмм (2- и 3-буквенные комбинации) на основе всех слова из вашего словаря, и используйте это, чтобы расставить приоритеты вашего поиска. Я бы пошел с начальными буквами слов. Поэтому, если в вашем словаре содержатся слова «Индия», «Вода», «Экстрим» и «Необыкновенный», то ваша предварительно вычисленная таблица может быть:

'IN': 1
'WA': 1
'EX': 2

Затем найдите эти диграммы в порядке общности (сначала EX, затем WA / IN)

4
14.04.2009 02:20:32

Я предлагаю сделать дерево букв на основе слов. Дерево будет состоять из буквенных структур, например:

letter: char
isWord: boolean

Затем вы строите дерево, с каждой глубиной добавляя новую букву. Другими словами, на первом уровне был бы алфавит; затем с каждого из этих деревьев будут еще 26 записей и так далее, пока вы не произнесете все слова. Держитесь за это проанализированное дерево, и оно сделает все возможные ответы быстрее, чтобы искать.

С этим разобранным деревом вы можете очень быстро найти решения. Вот псевдокод:

BEGIN: 
    For each letter:
        if the struct representing it on the current depth has isWord == true, enter it as an answer.
        Cycle through all its neighbors; if there is a child of the current node corresponding to the letter, recursively call BEGIN on it.

Это может быть ускорено с помощью небольшого динамического программирования. Например, в вашем примере два «А» находятся рядом с «Е» и «W», которые (с точки, с которой они их ударили) будут идентичны. У меня нет достаточно времени, чтобы действительно написать код для этого, но я думаю, что вы можете собрать идею.

Кроме того, я уверен, что вы найдете другие решения, если вы Google для "Boggle Solver".

4
14.04.2009 02:25:19

Веселое. Я чуть не опубликовал тот же вопрос несколько дней назад из-за той же чёртовой игры! Я не сделал, однако, потому что только искал в Google поисковик boggle Solver и получил все ответы, которые я мог хотеть.

3
14.04.2009 03:53:51
Я не знал, что популярным названием было «офигительно», но я нашел кое-что в Google, мне было просто интересно посмотреть, что люди придумают на SO. :)
Paolo Bergantino 14.04.2009 04:37:11

Вы можете разбить проблему на две части:

  1. Какой-то алгоритм поиска, который будет перечислять возможные строки в сетке.
  2. Способ проверки, является ли строка допустимым словом.

В идеале (2) также должен включать способ проверки, является ли строка префиксом допустимого слова - это позволит вам сократить поиск и сэкономить кучу времени.

Три Адама Розенфилда является решением (2). Это элегантно и, вероятно, то, что предпочитает ваш специалист по алгоритмам, но с современными языками и современными компьютерами мы можем быть немного ленивее. Также, как предполагает Кент, мы можем уменьшить размер нашего словаря, отбрасывая слова, буквы которых отсутствуют в сетке. Вот немного питона:

def make_lookups(grid, fn='dict.txt'):
    # Make set of valid characters.
    chars = set()
    for word in grid:
        chars.update(word)

    words = set(x.strip() for x in open(fn) if set(x.strip()) <= chars)
    prefixes = set()
    for w in words:
        for i in range(len(w)+1):
            prefixes.add(w[:i])

    return words, prefixes

Ух ты; постоянное тестирование префиксов. Загрузка словаря, на который вы ссылаетесь, занимает пару секунд, но только пару :-) (обратите внимание words <= prefixes)

Теперь, что касается части (1), я склонен думать в терминах графиков. Поэтому я создам словарь, который выглядит примерно так:

graph = { (x, y):set([(x0,y0), (x1,y1), (x2,y2)]), }

то graph[(x, y)]есть набор координат, которые вы можете достичь из позиции (x, y). Я также добавлю фиктивный узел, Noneкоторый будет соединяться со всем.

Создание это немного неуклюже, потому что есть 8 возможных позиций, и вы должны сделать проверку границ. Вот некоторый соответственно неуклюжий код Python:

def make_graph(grid):
    root = None
    graph = { root:set() }
    chardict = { root:'' }

    for i, row in enumerate(grid):
        for j, char in enumerate(row):
            chardict[(i, j)] = char
            node = (i, j)
            children = set()
            graph[node] = children
            graph[root].add(node)
            add_children(node, children, grid)

    return graph, chardict

def add_children(node, children, grid):
    x0, y0 = node
    for i in [-1,0,1]:
        x = x0 + i
        if not (0 <= x < len(grid)):
            continue
        for j in [-1,0,1]:
            y = y0 + j
            if not (0 <= y < len(grid[0])) or (i == j == 0):
                continue

            children.add((x,y))

Этот код также создает словарь сопоставления (x,y)с соответствующим символом. Это позволяет мне превратить список позиций в слово:

def to_word(chardict, pos_list):
    return ''.join(chardict[x] for x in pos_list)

Наконец, мы делаем поиск в глубину. Основная процедура:

  1. Поиск прибывает в определенный узел.
  2. Проверьте, может ли путь до сих пор быть частью слова. Если нет, не исследуйте эту ветку дальше.
  3. Проверьте, является ли путь до сих пор словом. Если это так, добавьте в список результатов.
  4. Исследуйте всех детей, не являющихся частью пути до сих пор.

Python:

def find_words(graph, chardict, position, prefix, results, words, prefixes):
    """ Arguments:
      graph :: mapping (x,y) to set of reachable positions
      chardict :: mapping (x,y) to character
      position :: current position (x,y) -- equals prefix[-1]
      prefix :: list of positions in current string
      results :: set of words found
      words :: set of valid words in the dictionary
      prefixes :: set of valid words or prefixes thereof
    """
    word = to_word(chardict, prefix)

    if word not in prefixes:
        return

    if word in words:
        results.add(word)

    for child in graph[position]:
        if child not in prefix:
            find_words(graph, chardict, child, prefix+[child], results, words, prefixes)

Запустите код как:

grid = ['fxie', 'amlo', 'ewbx', 'astu']
g, c = make_graph(grid)
w, p = make_lookups(grid)
res = set()
find_words(g, c, None, [], res, w, p)

и проверить, resчтобы увидеть ответы. Вот список слов, найденных для вашего примера, отсортированных по размеру:

 ['a', 'b', 'e', 'f', 'i', 'l', 'm', 'o', 's', 't',
 'u', 'w', 'x', 'ae', 'am', 'as', 'aw', 'ax', 'bo',
 'bu', 'ea', 'el', 'em', 'es', 'fa', 'ie', 'io', 'li',
 'lo', 'ma', 'me', 'mi', 'oe', 'ox', 'sa', 'se', 'st',
 'tu', 'ut', 'wa', 'we', 'xi', 'aes', 'ame', 'ami',
 'ase', 'ast', 'awa', 'awe', 'awl', 'blo', 'but', 'elb',
 'elm', 'fae', 'fam', 'lei', 'lie', 'lim', 'lob', 'lox',
 'mae', 'maw', 'mew', 'mil', 'mix', 'oil', 'olm', 'saw',
 'sea', 'sew', 'swa', 'tub', 'tux', 'twa', 'wae', 'was',
 'wax', 'wem', 'ambo', 'amil', 'amli', 'asem', 'axil',
 'axle', 'bleo', 'boil', 'bole', 'east', 'fame', 'limb',
 'lime', 'mesa', 'mewl', 'mile', 'milo', 'oime', 'sawt',
 'seam', 'seax', 'semi', 'stub', 'swam', 'twae', 'twas',
 'wame', 'wase', 'wast', 'weam', 'west', 'amble', 'awest',
 'axile', 'embox', 'limbo', 'limes', 'swami', 'embole',
 'famble', 'semble', 'wamble']

Код загружает (буквально) пару секунд, чтобы загрузить словарь, но остальное мгновенно на моем компьютере.

33
15.04.2009 00:33:03
Очень хорошо! Очень быстро тоже. Я собираюсь подождать, чтобы посмотреть, подойдет ли кто-нибудь еще к тарелке, но ваш ответ пока выглядит хорошо.
Paolo Bergantino 14.04.2009 04:39:58
Я запутался, почему слово «эмбол» - ваше единственное 6-буквенное слово, у меня есть 10 разных слов для этого. Похоже, что вы запрещаете посещать один и тот же узел дважды, и, как заявил ОП, это честная игра.
Kent Fredric 14.04.2009 13:34:37
хорошо, он все еще, возможно, получил ошибку, поскольку он отбрасывает "FAMBLE", "WAMBLE" и "SEMBLE", которые не разделяют символы.
Kent Fredric 14.04.2009 15:31:16
Хорошо подмечено! Ошибка заключалась в создании набора префиксов: мне нужно было использовать range(len(w)+1)вместо range(len(w)). Я утверждал это, words <= prefixesно, очевидно, я не проверял это: - /
John Fouhy 14.04.2009 22:00:30
Это помогло мне узнать, как работает DFS и как ее реализовать. Не был уверен ни в каком способе выразить признательность за это кроме как с комментарием. Спасибо!
Graham Smith 10.01.2014 21:10:30

Для ускорения работы словаря существует одно общее преобразование / процесс, который вы можете сделать, чтобы значительно сократить сравнение словаря заранее.

Учитывая, что приведенная выше сетка содержит только 16 символов, некоторые из которых дублируются, вы можете значительно сократить общее количество ключей в своем словаре, просто отфильтровывая записи, содержащие недостижимые символы.

Я думал, что это была очевидная оптимизация, но видя, что никто не сделал этого, я упоминаю об этом.

Это уменьшило меня от словаря из 200 000 ключей до всего 2000 ключей просто во время прохода ввода. Это, по крайней мере, уменьшает накладные расходы памяти, и это обязательно приведет к увеличению скорости где-то, поскольку память не бесконечно быстра.

Реализация Perl

Моя реализация немного перегружена, потому что я придавал большое значение тому, чтобы знать точный путь каждой извлеченной строки, а не только ее достоверность.

У меня также есть несколько адаптаций, которые теоретически позволяют сетке с отверстиями в ней функционировать и сеткам с линиями разных размеров (при условии, что вы правильно вводите данные, и они как-то выстраиваются в линию).

Ранний фильтр, безусловно, является наиболее значительным узким местом в моем приложении, как и предполагалось ранее, комментируя, что эта строка увеличивает его с 1,5 до 7,5 с.

После выполнения кажется, что все отдельные цифры состоят из собственных допустимых слов, но я вполне уверен, что из-за того, как работает файл словаря.

Это немного раздутый, но, по крайней мере, я снова использую Tree :: Trie из cpan

Некоторые из них были частично вдохновлены существующими реализациями, некоторые из них я уже имел в виду.

Конструктивная критика и способы ее улучшения приветствуются (/ я отмечает, что он никогда не искал CPAN для решения проблемы , но работать было веселее)

обновлен по новым критериям

#!/usr/bin/perl 

use strict;
use warnings;

{

  # this package manages a given path through the grid.
  # Its an array of matrix-nodes in-order with
  # Convenience functions for pretty-printing the paths
  # and for extending paths as new paths.

  # Usage:
  # my $p = Prefix->new(path=>[ $startnode ]);
  # my $c = $p->child( $extensionNode );
  # print $c->current_word ;

  package Prefix;
  use Moose;

  has path => (
      isa     => 'ArrayRef[MatrixNode]',
      is      => 'rw',
      default => sub { [] },
  );
  has current_word => (
      isa        => 'Str',
      is         => 'rw',
      lazy_build => 1,
  );

  # Create a clone of this object
  # with a longer path

  # $o->child( $successive-node-on-graph );

  sub child {
      my $self    = shift;
      my $newNode = shift;
      my $f       = Prefix->new();

      # Have to do this manually or other recorded paths get modified
      push @{ $f->{path} }, @{ $self->{path} }, $newNode;
      return $f;
  }

  # Traverses $o->path left-to-right to get the string it represents.

  sub _build_current_word {
      my $self = shift;
      return join q{}, map { $_->{value} } @{ $self->{path} };
  }

  # Returns  the rightmost node on this path

  sub tail {
      my $self = shift;
      return $self->{path}->[-1];
  }

  # pretty-format $o->path

  sub pp_path {
      my $self = shift;
      my @path =
        map { '[' . $_->{x_position} . ',' . $_->{y_position} . ']' }
        @{ $self->{path} };
      return "[" . join( ",", @path ) . "]";
  }

  # pretty-format $o
  sub pp {
      my $self = shift;
      return $self->current_word . ' => ' . $self->pp_path;
  }

  __PACKAGE__->meta->make_immutable;
}

{

  # Basic package for tracking node data
  # without having to look on the grid.
  # I could have just used an array or a hash, but that got ugly.

# Once the matrix is up and running it doesn't really care so much about rows/columns,
# Its just a sea of points and each point has adjacent points.
# Relative positioning is only really useful to map it back to userspace

  package MatrixNode;
  use Moose;

  has x_position => ( isa => 'Int', is => 'rw', required => 1 );
  has y_position => ( isa => 'Int', is => 'rw', required => 1 );
  has value      => ( isa => 'Str', is => 'rw', required => 1 );
  has siblings   => (
      isa     => 'ArrayRef[MatrixNode]',
      is      => 'rw',
      default => sub { [] }
  );

# Its not implicitly uni-directional joins. It would be more effient in therory
# to make the link go both ways at the same time, but thats too hard to program around.
# and besides, this isn't slow enough to bother caring about.

  sub add_sibling {
      my $self    = shift;
      my $sibling = shift;
      push @{ $self->siblings }, $sibling;
  }

  # Convenience method to derive a path starting at this node

  sub to_path {
      my $self = shift;
      return Prefix->new( path => [$self] );
  }
  __PACKAGE__->meta->make_immutable;

}

{

  package Matrix;
  use Moose;

  has rows => (
      isa     => 'ArrayRef',
      is      => 'rw',
      default => sub { [] },
  );

  has regex => (
      isa        => 'Regexp',
      is         => 'rw',
      lazy_build => 1,
  );

  has cells => (
      isa        => 'ArrayRef',
      is         => 'rw',
      lazy_build => 1,
  );

  sub add_row {
      my $self = shift;
      push @{ $self->rows }, [@_];
  }

  # Most of these functions from here down are just builder functions,
  # or utilities to help build things.
  # Some just broken out to make it easier for me to process.
  # All thats really useful is add_row
  # The rest will generally be computed, stored, and ready to go
  # from ->cells by the time either ->cells or ->regex are called.

  # traverse all cells and make a regex that covers them.
  sub _build_regex {
      my $self  = shift;
      my $chars = q{};
      for my $cell ( @{ $self->cells } ) {
          $chars .= $cell->value();
      }
      $chars = "[^$chars]";
      return qr/$chars/i;
  }

  # convert a plain cell ( ie: [x][y] = 0 )
  # to an intelligent cell ie: [x][y] = object( x, y )
  # we only really keep them in this format temporarily
  # so we can go through and tie in neighbouring information.
  # after the neigbouring is done, the grid should be considered inoperative.

  sub _convert {
      my $self = shift;
      my $x    = shift;
      my $y    = shift;
      my $v    = $self->_read( $x, $y );
      my $n    = MatrixNode->new(
          x_position => $x,
          y_position => $y,
          value      => $v,
      );
      $self->_write( $x, $y, $n );
      return $n;
  }

# go through the rows/collums presently available and freeze them into objects.

  sub _build_cells {
      my $self = shift;
      my @out  = ();
      my @rows = @{ $self->{rows} };
      for my $x ( 0 .. $#rows ) {
          next unless defined $self->{rows}->[$x];
          my @col = @{ $self->{rows}->[$x] };
          for my $y ( 0 .. $#col ) {
              next unless defined $self->{rows}->[$x]->[$y];
              push @out, $self->_convert( $x, $y );
          }
      }
      for my $c (@out) {
          for my $n ( $self->_neighbours( $c->x_position, $c->y_position ) ) {
              $c->add_sibling( $self->{rows}->[ $n->[0] ]->[ $n->[1] ] );
          }
      }
      return \@out;
  }

  # given x,y , return array of points that refer to valid neighbours.
  sub _neighbours {
      my $self = shift;
      my $x    = shift;
      my $y    = shift;
      my @out  = ();
      for my $sx ( -1, 0, 1 ) {
          next if $sx + $x < 0;
          next if not defined $self->{rows}->[ $sx + $x ];
          for my $sy ( -1, 0, 1 ) {
              next if $sx == 0 && $sy == 0;
              next if $sy + $y < 0;
              next if not defined $self->{rows}->[ $sx + $x ]->[ $sy + $y ];
              push @out, [ $sx + $x, $sy + $y ];
          }
      }
      return @out;
  }

  sub _has_row {
      my $self = shift;
      my $x    = shift;
      return defined $self->{rows}->[$x];
  }

  sub _has_cell {
      my $self = shift;
      my $x    = shift;
      my $y    = shift;
      return defined $self->{rows}->[$x]->[$y];
  }

  sub _read {
      my $self = shift;
      my $x    = shift;
      my $y    = shift;
      return $self->{rows}->[$x]->[$y];
  }

  sub _write {
      my $self = shift;
      my $x    = shift;
      my $y    = shift;
      my $v    = shift;
      $self->{rows}->[$x]->[$y] = $v;
      return $v;
  }

  __PACKAGE__->meta->make_immutable;
}

use Tree::Trie;

sub readDict {
  my $fn = shift;
  my $re = shift;
  my $d  = Tree::Trie->new();

  # Dictionary Loading
  open my $fh, '<', $fn;
  while ( my $line = <$fh> ) {
      chomp($line);

 # Commenting the next line makes it go from 1.5 seconds to 7.5 seconds. EPIC.
      next if $line =~ $re;    # Early Filter
      $d->add( uc($line) );
  }
  return $d;
}

sub traverseGraph {
  my $d     = shift;
  my $m     = shift;
  my $min   = shift;
  my $max   = shift;
  my @words = ();

  # Inject all grid nodes into the processing queue.

  my @queue =
    grep { $d->lookup( $_->current_word ) }
    map  { $_->to_path } @{ $m->cells };

  while (@queue) {
      my $item = shift @queue;

      # put the dictionary into "exact match" mode.

      $d->deepsearch('exact');

      my $cword = $item->current_word;
      my $l     = length($cword);

      if ( $l >= $min && $d->lookup($cword) ) {
          push @words,
            $item;    # push current path into "words" if it exactly matches.
      }
      next if $l > $max;

      # put the dictionary into "is-a-prefix" mode.
      $d->deepsearch('boolean');

    siblingloop: foreach my $sibling ( @{ $item->tail->siblings } ) {
          foreach my $visited ( @{ $item->{path} } ) {
              next siblingloop if $sibling == $visited;
          }

          # given path y , iterate for all its end points
          my $subpath = $item->child($sibling);

          # create a new path for each end-point
          if ( $d->lookup( $subpath->current_word ) ) {

             # if the new path is a prefix, add it to the bottom of the queue.
              push @queue, $subpath;
          }
      }
  }
  return \@words;
}

sub setup_predetermined { 
  my $m = shift; 
  my $gameNo = shift;
  if( $gameNo == 0 ){
      $m->add_row(qw( F X I E ));
      $m->add_row(qw( A M L O ));
      $m->add_row(qw( E W B X ));
      $m->add_row(qw( A S T U ));
      return $m;
  }
  if( $gameNo == 1 ){
      $m->add_row(qw( D G H I ));
      $m->add_row(qw( K L P S ));
      $m->add_row(qw( Y E U T ));
      $m->add_row(qw( E O R N ));
      return $m;
  }
}
sub setup_random { 
  my $m = shift; 
  my $seed = shift;
  srand $seed;
  my @letters = 'A' .. 'Z' ; 
  for( 1 .. 4 ){ 
      my @r = ();
      for( 1 .. 4 ){
          push @r , $letters[int(rand(25))];
      }
      $m->add_row( @r );
  }
}

# Here is where the real work starts.

my $m = Matrix->new();
setup_predetermined( $m, 0 );
#setup_random( $m, 5 );

my $d = readDict( 'dict.txt', $m->regex );
my $c = scalar @{ $m->cells };    # get the max, as per spec

print join ",\n", map { $_->pp } @{
  traverseGraph( $d, $m, 3, $c ) ;
};

Информация об арке / исполнении для сравнения:

model name      : Intel(R) Core(TM)2 Duo CPU     T9300  @ 2.50GHz
cache size      : 6144 KB
Memory usage summary: heap total: 77057577, heap peak: 11446200, stack peak: 26448
       total calls   total memory   failed calls
 malloc|     947212       68763684              0
realloc|      11191        1045641              0  (nomove:9063, dec:4731, free:0)
 calloc|     121001        7248252              0
   free|     973159       65854762

Histogram for block sizes:
  0-15         392633  36% ==================================================
 16-31          43530   4% =====
 32-47          50048   4% ======
 48-63          70701   6% =========
 64-79          18831   1% ==
 80-95          19271   1% ==
 96-111        238398  22% ==============================
112-127          3007  <1% 
128-143        236727  21% ==============================

Больше бормотаний на эту оптимизацию Regex

Оптимизация регулярных выражений, которую я использую, бесполезна для словарей с несколькими решениями, а для нескольких решений вам понадобится полный словарь, а не предварительно урезанный.

Тем не менее, для одноразовых решений это действительно быстро. (Perl регулярные выражения в C! :))

Вот несколько различных дополнений кода:

sub readDict_nofilter {
  my $fn = shift;
  my $re = shift;
  my $d  = Tree::Trie->new();

  # Dictionary Loading
  open my $fh, '<', $fn;
  while ( my $line = <$fh> ) {
      chomp($line);
      $d->add( uc($line) );
  }
  return $d;
}

sub benchmark_io { 
  use Benchmark qw( cmpthese :hireswallclock );
   # generate a random 16 character string 
   # to simulate there being an input grid. 
  my $regexen = sub { 
      my @letters = 'A' .. 'Z' ; 
      my @lo = ();
      for( 1..16 ){ 
          push @lo , $_ ; 
      }
      my $c  = join '', @lo;
      $c = "[^$c]";
      return qr/$c/i;
  };
  cmpthese( 200 , { 
      filtered => sub { 
          readDict('dict.txt', $regexen->() );
      }, 
      unfil
39
9.05.2014 05:21:09
Я знаю, что проваливаюсь в клубе оптимизации, но у меня были проблемы со скоростью, прежде чем я приступил к реальной работе кода, и сокращение времени ввода с 2 до 1,2 с очень много значит для меня.
Kent Fredric 14.04.2009 10:04:48
/ me отметил, что странно, что теперь для регулярного выражения и пропуска записей требуется меньше времени, чем для добавления ключей в хеш.
Kent Fredric 14.04.2009 10:05:37
Хорошо, реализация Perl! Я пойду бегать сейчас.
Paolo Bergantino 14.04.2009 13:20:07
Блерг, мне сложно установить Tree :: Trie на мой веб-сервер. :(
Paolo Bergantino 14.04.2009 13:46:53
Как вы сгенерировали этот последний отчет (информация об арке / исполнении)? Выглядит полезным.
jmanning2k 14.04.2009 16:13:19

Не заинтересованы в VB? :) Я не мог устоять. Я решил это иначе, чем многие из представленных здесь решений.

Мои времена:

  • Загрузка словаря и префиксов слов в хеш-таблицу: от 0,5 до 1 секунды.
  • Нахождение слов: усреднение менее 10 миллисекунд.

РЕДАКТИРОВАТЬ: время загрузки словаря на сервере веб-хоста работает примерно на 1-1,5 секунды дольше, чем мой домашний компьютер.

Я не знаю, насколько сильно ухудшится время с нагрузкой на сервер.

Я написал свое решение в виде веб-страницы в .Net. myvrad.com/boggle

Я использую словарь, указанный в оригинальном вопросе.

Письма не используются повторно одним словом. Найдены только слова длиной не более 3 символов.

Я использую хеш-таблицу всех уникальных префиксов и слов вместо слова. Я не знал о Три, поэтому я кое-что узнал там. Идея создания списка префиксов слов в дополнение к полным словам - это то, что, наконец, привело к тому, что мое время сократилось до порядочного числа.

Прочитайте комментарии к коду для получения дополнительной информации.

Вот код:

Imports System.Collections.Generic
Imports System.IO

Partial Class boggle_Default

    'Bob Archer, 4/15/2009

    'To avoid using a 2 dimensional array in VB I'm not using typical X,Y
    'coordinate iteration to find paths.
    '
    'I have locked the code into a 4 by 4 grid laid out like so:
    ' abcd
    ' efgh
    ' ijkl
    ' mnop
    ' 
    'To find paths the code starts with a letter from a to p then
    'explores the paths available around it. If a neighboring letter
    'already exists in the path then we don't go there.
    '
    'Neighboring letters (grid points) are hard coded into
    'a Generic.Dictionary below.



    'Paths is a list of only valid Paths found. 
    'If a word prefix or word is not found the path is not
    'added and extending that path is terminated.
    Dim Paths As New Generic.List(Of String)

    'NeighborsOf. The keys are the letters a to p.
    'The value is a string of letters representing neighboring letters.
    'The string of neighboring letters is split and iterated later.
    Dim NeigborsOf As New Generic.Dictionary(Of String, String)

    'BoggleLetters. The keys are mapped to the lettered grid of a to p.
    'The values are what the user inputs on the page.
    Dim BoggleLetters As New Generic.Dictionary(Of String, String)

    'Used to store last postition of path. This will be a letter
    'from a to p.
    Dim LastPositionOfPath As String = ""

    'I found a HashTable was by far faster than a Generic.Dictionary 
    ' - about 10 times faster. This stores prefixes of words and words.
    'I determined 792773 was the number of words and unique prefixes that
    'will be generated from the dictionary file. This is a max number and
    'the final hashtable will not have that many.
    Dim HashTableOfPrefixesAndWords As New Hashtable(792773)

    'Stores words that are found.
    Dim FoundWords As New Generic.List(Of String)

    'Just to validate what the user enters in the grid.
    Dim ErrorFoundWithSubmittedLetters As Boolean = False

    Public Sub BuildAndTestPathsAndFindWords(ByVal ThisPath As String)
        'Word is the word correlating to the ThisPath parameter.
        'This path would be a series of letters from a to p.
        Dim Word As String = ""

        'The path is iterated through and a word based on the actual
        'letters in the Boggle grid is assembled.
        For i As Integer = 0 To ThisPath.Length - 1
            Word += Me.BoggleLetters(ThisPath.Substring(i, 1))
        Next

        'If my hashtable of word prefixes and words doesn't contain this Word
        'Then this isn't a word and any further extension of ThisPath will not
        'yield any words either. So exit sub to terminate exploring this path.
        If Not HashTableOfPrefixesAndWords.ContainsKey(Word) Then Exit Sub

        'The value of my hashtable is a boolean representing if the key if a word (true) or
        'just a prefix (false). If true and at least 3 letters long then yay! word found.
        If HashTableOfPrefixesAndWords(Word) AndAlso Word.Length > 2 Then Me.FoundWords.Add(Word)

        'If my List of Paths doesn't contain ThisPath then add it.
        'Remember only valid paths will make it this far. Paths not found
        'in the HashTableOfPrefixesAndWords cause this sub to exit above.
        If Not Paths.Contains(ThisPath) Then Paths.Add(ThisPath)

        'Examine the last letter of ThisPath. We are looking to extend the path
        'to our neighboring letters if any are still available.
        LastPositionOfPath = ThisPath.Substring(ThisPath.Length - 1, 1)

        'Loop through my list of neighboring letters (representing grid points).
        For Each Neighbor As String In Me.NeigborsOf(LastPositionOfPath).ToCharArray()
            'If I find a neighboring grid point that I haven't already used
            'in ThisPath then extend ThisPath and feed the new path into
            'this recursive function. (see recursive.)
            If Not ThisPath.Contains(Neighbor) Then Me.BuildAndTestPathsAndFindWords(ThisPath & Neighbor)
        Next
    End Sub

    Protected Sub ButtonBoggle_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles ButtonBoggle.Click

        'User has entered the 16 letters and clicked the go button.

        'Set up my Generic.Dictionary of grid points, I'm using letters a to p -
        'not an x,y grid system.  The values are neighboring points.
        NeigborsOf.Add("a", "bfe")
        NeigborsOf.Add("b", "cgfea")
        NeigborsOf.Add("c", "dhgfb")
        NeigborsOf.Add("d", "hgc")
        NeigborsOf.Add("e", "abfji")
        NeigborsOf.Add("f", "abcgkjie")
        NeigborsOf.Add("g", "bcdhlkjf")
        NeigborsOf.Add("h", "cdlkg")
        NeigborsOf.Add("i", "efjnm")
        NeigborsOf.Add("j", "efgkonmi")
        NeigborsOf.Add("k", "fghlponj")
        NeigborsOf.Add("l", "ghpok")
        NeigborsOf.Add("m", "ijn")
        NeigborsOf.Add("n", "ijkom")
        NeigborsOf.Add("o", "jklpn")
        NeigborsOf.Add("p", "klo")

        'Retrieve letters the user entered.
        BoggleLetters.Add("a", Me.TextBox1.Text.ToLower.Trim())
        BoggleLetters.Add("b", Me.TextBox2.Text.ToLower.Trim())
        BoggleLetters.Add("c", Me.TextBox3.Text.ToLower.Trim())
        BoggleLetters.Add("d", Me.TextBox4.Text.ToLower.Trim())
        BoggleLetters.Add("e", Me.TextBox5.Text.ToLower.Trim())
        BoggleLetters.Add("f", Me.TextBox6.Text.ToLower.Trim())
        BoggleLetters.Add("g", Me.TextBox7.Text.ToLower.Trim())
        BoggleLetters.Add("h", Me.TextBox8.Text.ToLower.Trim())
        BoggleLetters.Add("i", Me.TextBox9.Text.ToLower.Trim())
        BoggleLetters.Add("j", Me.TextBox10.Text.ToLower.Trim())
        BoggleLetters.Add("k", Me.TextBox11.Text.ToLower.Trim())
        BoggleLetters.Add("l", Me.TextBox12.Text.ToLower.Trim())
        BoggleLetters.Add("m", Me.TextBox13.Text.ToLower.Trim())
        BoggleLetters.Add("n", Me.TextBox14.Text.ToLower.Trim())
        BoggleLetters.Add("o", Me.TextBox15.Text.ToLower.Trim())
        BoggleLetters.Add("p", Me.TextBox16.Text.ToLower.Trim())

        'Validate user entered something with a length of 1 for all 16 textboxes.
        For Each S As String In BoggleLetters.Keys
            If BoggleLetters(S).Length <> 1 Then
                ErrorFoundWithSubmittedLetters = True
                Exit For
            End If
        Next

        'If input is not valid then...
        If ErrorFoundWithSubmittedLetters Then
            'Present error message.
        Else
            'Else assume we have 16 letters to work with and start finding words.
            Dim SB As New StringBuilder

            Dim Time As String = String.Format("{0}:{1}:{2}:{3}", Date.Now.Hour.ToString(), Date.Now.Minute.ToString(), Date.Now.Second.ToString(), Date.Now.Millisecond.ToString())

            Dim NumOfLetters As Integer = 0
            Dim Word As String = ""
            Dim TempWord As String = ""
            Dim Letter As String = ""
            Dim fr As StreamReader = Nothing
            fr = New System.IO.StreamReader(HttpContext.Current.Request.MapPath("~/boggle/dic.txt"))

            'First fill my hashtable with word prefixes and words.
            'HashTable(PrefixOrWordString, BooleanTrueIfWordFalseIfPrefix)
            While fr.Peek <> -1
                Word = fr.ReadLine.Trim()
                TempWord = ""
                For i As Integer = 0 To Word.Length - 1
                    Letter = Word.Substring(i, 1)
                    'This optimization helped quite a bit. Words in the dictionary that begin
                    'with letters that the user did not enter in the grid shouldn't go in my hashtable.
                    '
                    'I realize most of the solutions went with a Trie. I'd never heard of that before,
                    'which is one of the neat things about SO, seeing how others approach challenges
                    'and learning some best practices.
                    '
                    'However, I didn't code a Trie in my solution. I just have a hashtable with 
                    'all words in the dicitonary file and all possible prefixes for those words.
                    'A Trie might be faster but I'm not coding it now. I'm getting good times with this.
                    If i = 0 AndAlso Not BoggleLetters.ContainsValue(Letter) Then Continue While
                    TempWord += Letter
                    If Not HashTableOfPrefixesAndWords.ContainsKey(TempWord) Then
                        HashTableOfPrefixesAndWords.Add(TempWord, TempWord = Word)
                    End If
                Next
            End While

            SB.Append("Number of Word Prefixes and Words in Hashtable: " & HashTableOfPrefixesAndWords.Count.ToString())
            SB.Append("<br />")

            SB.Append("Loading Dictionary: " & Time & " - " & String.Format("{0}:{1}:{2}:{3}", Date.Now.Hour.ToString(), Date.Now.Minute.ToString(), Date.Now.Second.ToString(), Date.Now.Millisecond.ToString()))
            SB.Append("<br />")

            Time = String.Format("{0}:{1}:{2}:{3}", Date.Now.Hour.ToString(), Date.Now.Minute.ToString(), Date.Now.Second.ToString(), Date.Now.Millisecond.ToString())

            'This starts a path at each point on the grid an builds a path until 
            'the string of letters correlating to the path is not found in the hashtable
            'of word prefixes and words.
            Me.BuildAndTestPathsAndFindWords("a")
            Me.BuildAndTestPathsAndFindWords("b")
            Me.BuildAndTestPathsAndFindWords("c")
            Me.BuildAndTestPathsAndFindWords("d")
            Me.BuildAndTestPathsAndFindWords("e")
            Me.BuildAndTestPathsAndFindWords("f")
            Me.BuildAndTestPathsAndFindWords("g")
            Me.BuildAndTestPathsAndFindWords("h")
            Me.BuildAndTestPathsAndFindWords("i")
            Me.BuildAndTestPathsAndFindWords("j")
            Me.BuildAndTestPathsAndFindWords("k")
            Me.BuildAndTestPathsAndFindWords("l")
            Me.BuildAndTestPathsAndFindWords("m")
            Me.BuildAndTestPathsAndFindWords("n")
            Me.BuildAndTestPathsAndFindWords("o")
            Me.BuildAndTestPathsAndFindWords("p")

            SB.Append("Finding Words: " & Time & " - " & String.Format("{0}:{1}:{2}:{3}", Date.Now.Hour.ToString(), Date.Now.Minute.ToString(), Date.Now.Second.ToString(), Date.Now.Millisecond.ToString()))
            SB.Append("<br />")

            SB.Append("Num of words found: " & FoundWords.Count.ToString())
            SB.Append("<br />")
            SB.Append("<br />")

            FoundWords.Sort()
            SB.Append(String.Join("<br />", FoundWords.ToArray()))

            'Output results.
            Me.LiteralBoggleResults.Text = SB.ToString()
            Me.PanelBoggleResults.Visible = True

        End If

    End Sub

End Class
16
15.04.2009 08:14:01
Я собираюсь предположить, что здесь вы использовали систему ap вместо [x] [y], потому что последняя довольно сложна в VB? Я потратил день, пытаясь получить двухсторонний динамический массив в этот раз, то есть: массив (массив (1, "привет"), 1, "привет", массив ()), все еще не знаю, как это сделать что: P
Kent Fredric 16.04.2009 12:39:56
В PHP и Perl 2 dim массивы - это весело. Это может быть сделано в VB, но я бы не назвал это увлекательным процессом. Dim Arr (,) As Integer = {{1,1}, {0,0}}. Процесс AP вырос из-за того, что я поставил себя в сетку и спросил: «Куда я могу пойти отсюда?» Я знаю, что это жесткое решение, но оно работает здесь.
rvarcher 16.04.2009 15:00:21
Ох, мне нравится VB.NET ... Я попробовал URL, но он не работал. Мне пришлось пересобрать ваш код как Windows Forms, и он работает. Спасибо.
Ahmed Eissa 9.04.2018 17:11:46

Удивительно, но никто не пытался PHP версию этого.

Это рабочая версия PHP решения Джона Фухи на Python.

Хотя я взял некоторые указатели из ответов всех остальных, это в основном скопировано с Джона.

$boggle = "fxie
           amlo
           ewbx
           astu";

$alphabet = str_split(str_replace(array("\n", " ", "\r"), "", strtolower($boggle)));
$rows = array_map('trim', explode("\n", $boggle));
$dictionary = file("C:/dict.txt");
$prefixes = array(''=>'');
$words = array();
$regex = '/[' . implode('', $alphabet) . ']{3,}$/S';
foreach($dictionary as $k=>$value) {
    $value = trim(strtolower($value));
    $length = strlen($value);
    if(preg_match($regex, $value)) {
        for($x = 0; $x < $length; $x++) {
            $letter = substr($value, 0, $x+1);
            if($letter == $value) {
                $words[$value] = 1;
            } else {
                $prefixes[$letter] = 1;
            }
        }
    }
}

$graph = array();
$chardict = array();
$positions = array();
$c = count($rows);
for($i = 0; $i < $c; $i++) {
    $l = strlen($rows[$i]);
    for($j = 0; $j < $l; $j++) {
        $chardict[$i.','.$j] = $rows[$i][$j];
        $children = array();
        $pos = array(-1,0,1);
        foreach($pos as $z) {
            $xCoord = $z + $i;
            if($xCoord < 0 || $xCoord >= count($rows)) {
                continue;
            }
            $len = strlen($rows[0]);
            foreach($pos as $w) {
                $yCoord = $j + $w;
                if(($yCoord < 0 || $yCoord >= $len) || ($z == 0 && $w == 0)) {
                    continue;
                }
                $children[] = array($xCoord, $yCoord);
            }
        }
        $graph['None'][] = array($i, $j);
        $graph[$i.','.$j] = $children;
    }
}

function to_word($chardict, $prefix) {
    $word = array();
    foreach($prefix as $v) {
        $word[] = $chardict[$v[0].','.$v[1]];
    }
    return implode("", $word);
}

function find_words($graph, $chardict, $position, $prefix, $prefixes, &$results, $words) {
    $word = to_word($chardict, $prefix);
    if(!isset($prefixes[$word])) return false;

    if(isset($words[$word])) {
        $results[] = $word;
    }

    foreach($graph[$position] as $child) {
        if(!in_array($child, $prefix)) {
            $newprefix = $prefix;
            $newprefix[] = $child;
            find_words($graph, $chardict, $child[0].','.$child[1], $newprefix, $prefixes, $results, $words);
        }
    }
}

$solution = array();
find_words($graph, $chardict, 'None', array(), $prefixes, $solution);
print_r($solution);

Вот прямая ссылка, если вы хотите попробовать это. Хотя на моем локальном компьютере это занимает ~ 2 с, на моем веб-сервере это занимает ~ 5 с. В любом случае это не очень быстро. Тем не менее, это довольно отвратительно, поэтому я могу себе представить, что время можно значительно сократить. Любые указатели о том, как этого добиться, будут оценены. Отсутствие кортежей в PHP сделало координаты странными для работы, и моя неспособность понять, что происходит, черт возьми, не помогла вообще.

РЕДАКТИРОВАТЬ : несколько исправлений сделать это займет менее 1 с локально.

19
3.07.2009 22:14:10
+1 @ "и моя неспособность понять, что, черт возьми, происходит, совсем не помогла". лол. Я люблю честность!
dna123 16.04.2009 21:45:24
Я не знаю PHP, но первое, что я попробую, это поднять '/ ['. взорваться ('', $ алфавит). '] {3,} $ /' вне цикла. То есть установите переменную на это и используйте переменную внутри цикла.
Darius Bacon 17.04.2009 06:32:14
Я уверен, что PHP хранит глобальный кэш для каждого потока скомпилированных регулярных выражений, но я все равно попробую.
Paolo Bergantino 17.04.2009 14:50:24
@ Даниель: Очевидно, это мой веб-сервер. Это не происходит, когда я бегу на месте. Shrug. Не очень хочется охотиться за ним.
Paolo Bergantino 3.07.2009 22:14:55
Что следует установить в качестве параметра 7. в конце функции find_words?
MikkoP 14.11.2012 17:58:07

Как только я увидел постановку задачи, я подумал: «Три». Но, учитывая, что несколько других авторов использовали этот подход, я искал другой подход, чтобы быть другим. Увы, подход Trie работает лучше. Я запустил решение Perl от Kent на своей машине, и мне потребовалось 0,31 секунды, чтобы адаптировать его для использования файла словаря. Моей собственной реализации на Perl потребовалось 0,54 секунды для запуска.

Это был мой подход:

  1. Создайте хеш перехода для моделирования законных переходов.

  2. Переберите все 16 ^ 3 возможных трехбуквенных комбинаций.

    • В цикле исключите недопустимые переходы и повторите посещения одного и того же квадрата. Сформируйте все допустимые 3-буквенные последовательности и сохраните их в хеше.
  3. Затем переберите все слова в словаре.

    • Исключить слова, которые слишком длинные или короткие
    • Сдвиньте трехбуквенное окно поперек каждого слова и посмотрите, входит ли оно в трехбуквенную комбинацию, начиная с шага 2. Исключите слова, которые заканчиваются неудачей. Это устраняет большинство несоответствий.
    • Если все еще не устранено, используйте рекурсивный алгоритм, чтобы увидеть, можно ли сформировать слово, прокладывая пути через головоломку. (Эта часть медленная, но вызывается нечасто.)
  4. Распечатайте слова, которые я нашел.

    Я попробовал 3-буквенные и 4-буквенные последовательности, но 4-буквенные последовательности замедлили программу.

В моем коде я использую / usr / share / dict / words для своего словаря. Он входит в стандартную комплектацию MAC OS X и многих систем Unix. Вы можете использовать другой файл, если хотите. Чтобы взломать другую головоломку, просто измените переменную @puzzle. Это было бы легко адаптировать для больших матриц. Вам просто нужно изменить хеш% переходов и хеш% legalTransitions.

Сила этого решения в том, что код короткий, а структуры данных простые.

Вот код Perl (который использует слишком много глобальных переменных, я знаю):

#!/usr/bin/perl
use Time::HiRes  qw{ time };

sub readFile($);
sub findAllPrefixes($);
sub isWordTraceable($);
sub findWordsInPuzzle(@);

my $startTime = time;

# Puzzle to solve

my @puzzle = ( 
    F, X, I, E,
    A, M, L, O,
    E, W, B, X,
    A, S, T, U
);

my $minimumWordLength = 3;
my $maximumPrefixLength = 3; # I tried four and it slowed down.

# Slurp the word list.
my $wordlistFile = "/usr/share/dict/words";

my @words = split(/\n/, uc(readFile($wordlistFile)));
print "Words loaded from word list: " . scalar @words . "\n";

print "Word file load time: " . (time - $startTime) . "\n";
my $postLoad = time;

# Define the legal transitions from one letter position to another. 
# Positions are numbered 0-15.
#     0  1  2  3
#     4  5  6  7
#     8  9 10 11
#    12 13 14 15
my %transitions = ( 
   -1 => [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],
    0 => [1,4,5], 
    1 => [0,2,4,5,6],
    2 => [1,3,5,6,7],
    3 => [2,6,7],
    4 => [0,1,5,8,9],
    5 => [0,1,2,4,6,8,9,10],
    6 => [1,2,3,5,7,9,10,11],
    7 => [2,3,6,10,11],
    8 => [4,5,9,12,13],
    9 => [4,5,6,8,10,12,13,14],
    10 => [5,6,7,9,11,13,14,15],
    11 => [6,7,10,14,15],
    12 => [8,9,13],
    13 => [8,9,10,12,14],
    14 => [9,10,11,13,15],
    15 => [10,11,14]
);

# Convert the transition matrix into a hash for easy access.
my %legalTransitions = ();
foreach my $start (keys %transitions) {
    my $legalRef = $transitions{$start};
    foreach my $stop (@$legalRef) {
        my $index = ($start + 1) * (scalar @puzzle) + ($stop + 1);
        $legalTransitions{$index} = 1;
    }
}

my %prefixesInPuzzle = findAllPrefixes($maximumPrefixLength);

print "Find prefixes time: " . (time - $postLoad) . "\n";
my $postPrefix = time;

my @wordsFoundInPuzzle = findWordsInPuzzle(@words);

print "Find words in puzzle time: " . (time - $postPrefix) . "\n";

print "Unique prefixes found: " . (scalar keys %prefixesInPuzzle) . "\n";
print "Words found (" . (scalar @wordsFoundInPuzzle) . ") :\n    " . join("\n    ", @wordsFoundInPuzzle) . "\n";

print "Total Elapsed time: " . (time - $startTime) . "\n";

###########################################

sub readFile($) {
    my ($filename) = @_;
    my $contents;
    if (-e $filename) {
        # This is magic: it opens and reads a file into a scalar in one line of code. 
        # See http://www.perl.com/pub/a/2003/11/21/slurp.html
        $contents = do { local( @ARGV, $/ ) = $filename ; <> } ; 
    }
    else {
        $contents = '';
    }
    return $contents;
}

# Is it legal to move from the first position to the second? They must be adjacent.
sub isLegalTransition($$) {
    my ($pos1,$pos2) = @_;
    my $index = ($pos1 + 1) * (scalar @puzzle) + ($pos2 + 1);
    return $legalTransitions{$index};
}

# Find all prefixes where $minimumWordLength <= length <= $maxPrefixLength
#
#   $maxPrefixLength ... Maximum length of prefix we will store. Three gives best performance. 
sub findAllPrefixes($) {
    my ($maxPrefixLength) = @_;
    my %prefixes = ();
    my $puzzleSize = scalar @puzzle;

    # Every possible N-letter combination of the letters in the puzzle 
    # can be represented as an integer, though many of those combinations
    # involve illegal transitions, duplicated letters, etc.
    # Iterate through all those possibilities and eliminate the illegal ones.
    my $maxIndex = $puzzleSize ** $maxPrefixLength;

    for (my $i = 0; $i < $maxIndex; $i++) {
        my @path;
        my $remainder = $i;
        my $prevPosition = -1;
        my $prefix = '';
        my %usedPositions = ();
        for (my $prefixLength = 1; $prefixLength <= $maxPrefixLength; $prefixLength++) {
            my $position = $remainder % $puzzleSize;

            # Is this a valid step?
            #  a. Is the transition legal (to an adjacent square)?
            if (! isLegalTransition($prevPosition, $position)) {
                last;
            }

            #  b. Have we repeated a square?
            if ($usedPositions{$position}) {
                last;
            }
            else {
                $usedPositions{$position} = 1;
            }

            # Record this prefix if length >= $minimumWordLength.
            $prefix .= $puzzle[$position];
            if ($prefixLength >= $minimumWordLength) {
                $prefixes{$prefix} = 1;
            }

            push @path, $position;
            $remainder -= $position;
            $remainder /= $puzzleSize;
            $prevPosition = $position;
        } # end inner for
    } # end outer for
    return %prefixes;
}

# Loop through all words in dictionary, looking for ones that are in the puzzle.
sub findWordsInPuzzle(@) {
    my @allWords = @_;
    my @wordsFound = ();
    my $puzzleSize = scalar @puzzle;
WORD: foreach my $word (@allWords) {
        my $wordLength = length($word);
        if ($wordLength > $puzzleSize || $wordLength < $minimumWordLength) {
            # Reject word as too short or too long.
        }
        elsif ($wordLength <= $maximumPrefixLength ) {
            # Word should be in the prefix hash.
            if ($prefixesInPuzzle{$word}) {
                push @wordsFound, $word;
            }
        }
        else {
            # Scan through the word using a window of length $maximumPrefixLength, looking for any strings not in our prefix list.
            # If any are found that are not in the list, this word is not possible.
            # If no non-matches are found, we have more work to do.
            my $limit = $wordLength - $maximumPrefixLength + 1;
            for (my $startIndex = 0; $startIndex < $limit; $startIndex ++) {
                if (! $prefixesInPuzzle{substr($word, $startIndex, $maximumPrefixLength)}) {
                    next WORD;
                }
            }
            if (isWordTraceable($word)) {
                # Additional test necessary: see if we can form this word by following legal transitions
                push @wordsFound, $word;
            }
        }

    }
    return @wordsFound;
}

# Is it possible to trace out the word using only legal transitions?
sub isWordTraceable($) {
    my $word = shift;
    return traverse([split(//, $word)], [-1]); # Start at special square -1, which may transition to any square in the puzzle.
}

# Recursively look for a path through the puzzle that matches the word.
sub traverse($$) {
    my ($lettersRef, $pathRef) = @_;
    my $index = scalar @$pathRef - 1;
    my $position = $pathRef->[$index];
    my $letter = $lettersRef->[$index];
    my $branchesRef =  $transitions{$position};
BRANCH: foreach my $branch (@$branchesRef) {
            if ($puzzle[$branch] eq $letter) {
                # Have we used this position yet?
                foreach my $usedBranch (@$pathRef) {
                    if ($usedBranch == $branch) {
                        next BRANCH;
                    }
                }
                if (scalar @$lettersRef == $index + 1) {
                    return 1; # End of word and success.
                }
                push @$pathRef, $branch;
                if (traverse($lettersRef, $pathRef)) {
                    return 1; # Recursive success.
                }
                else {
                    pop @$pathRef;
                }
            }
        }
    return 0; # No path found. Failed.
}
11
26.06.2009 05:43:29
Изменилось ли местоположение словаря? Я пытался найти слова из словаря, так как хотел сравнить свое решение со всеми, но не смог найти его по указанной ссылке в / usr / share / dict. Я знаю, что это довольно старая тема, но было бы здорово, если бы вы могли указать мне. Заранее спасибо за помощь.
Naman 4.06.2015 21:52:15
В данный момент мой Mac не пригодится. Все, что вам нужно, это файл с английскими словами, по одному в строке, разделенными символами новой строки. Вы можете найти такой файл в интернете. Один здесь: mieliestronk.com/corncob_lowercase.txt, но, вероятно, есть списки с большим количеством слов, чем это.
Paul Chernoch 26.06.2015 14:42:54
Большое спасибо за ответ. Я нашел это в файлах Ubuntu.
Naman 26.06.2015 14:58:32

Моя попытка в Java. Для считывания файла и построения файла требуется около 2 с, а для решения головоломки - около 50 мс. Я использовал словарь, связанный в вопросе (в нем есть несколько слов, которые я не знал, существуют в английском, такие как fae, ima)

0 [main] INFO gineer.bogglesolver.util.Util  - Reading the dictionary
2234 [main] INFO gineer.bogglesolver.util.Util  - Finish reading the dictionary
2234 [main] INFO gineer.bogglesolver.Solver  - Found: FAM
2234 [main] INFO gineer.bogglesolver.Solver  - Found: FAME
2234 [main] INFO gineer.bogglesolver.Solver  - Found: FAMBLE
2234 [main] INFO gineer.bogglesolver.Solver  - Found: FAE
2234 [main] INFO gineer.bogglesolver.Solver  - Found: IMA
2234 [main] INFO gineer.bogglesolver.Solver  - Found: ELI
2234 [main] INFO gineer.bogglesolver.Solver  - Found: ELM
2234 [main] INFO gineer.bogglesolver.Solver  - Found: ELB
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AXIL
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AXILE
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AXLE
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AMI
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AMIL
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AMLI
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AME
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AMBLE
2234 [main] INFO gineer.bogglesolver.Solver  - Found: AMBO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AES
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWEST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MIX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MIL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MILE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MILO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MAX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MAE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MAW
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MEW
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MEWL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MES
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MESA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: MWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMAX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIME
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMES
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMB
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMBO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LIMBU
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LEI
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LEO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LOB
2250 [main] INFO gineer.bogglesolver.Solver  - Found: LOX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: OIME
2250 [main] INFO gineer.bogglesolver.Solver  - Found: OIL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: OLE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: OLM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: EMIL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: EMBOLE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: EMBOX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: EAST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAF
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAME
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAMBLE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WEA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WEAM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WEM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WEA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WES
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WEST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAS
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WASE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: WAST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: BLEO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: BLO
2250 [main] INFO gineer.bogglesolver.Solver  - Found: BOIL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: BOLE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: BUT
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AES
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWL
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AWEST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: ASE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: ASEM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: AST
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEAX
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEAM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEMI
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEMBLE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEW
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SEA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SWAM
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SWAMI
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SAW
2250 [main] INFO gineer.bogglesolver.Solver  - Found: SAWT
2250 [main] INFO gineer.bogglesolver.Solver  - Found: STU
2250 [main] INFO gineer.bogglesolver.Solver  - Found: STUB
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TWAE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TWA
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TWAE
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TWAS
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TUB
2250 [main] INFO gineer.bogglesolver.Solver  - Found: TUX

Исходный код состоит из 6 классов. Я опубликую их ниже (если это не правильная практика в StackOverflow, пожалуйста, сообщите мне).

gineer.bogglesolver.Main

package gineer.bogglesolver;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;

public class Main
{
    private final static Logger logger = Logger.getLogger(Main.class);

    public static void main(String[] args)
    {
        BasicConfigurator.configure();

        Solver solver = new Solver(4,
                        "FXIE" +
                        "AMLO" +
                        "EWBX" +
                        "ASTU");
        solver.solve();

    }
}

gineer.bogglesolver.Solver

package gineer.bogglesolver;

import gineer.bogglesolver.trie.Trie;
import gineer.bogglesolver.util.Constants;
import gineer.bogglesolver.util.Util;
import org.apache.log4j.Logger;

public class Solver
{
    private char[] puzzle;
    private int maxSize;

    private boolean[] used;
    private StringBuilder stringSoFar;

    private boolean[][] matrix;
    private Trie trie;

    private final static Logger logger = Logger.getLogger(Solver.class);

    public Solver(int size, String puzzle)
    {
        trie = Util.getTrie(size);
        matrix = Util.connectivityMatrix(size);

        maxSize = size * size;
        stringSoFar = new StringBuilder(maxSize);
        used = new boolean[maxSize];

        if (puzzle.length() == maxSize)
        {
            this.puzzle = puzzle.toCharArray();
        }
        else
        {
            logger.error("The puzzle size does not match the size specified: " + puzzle.length());
            this.puzzle = puzzle.substring(0, maxSize).toCharArray();
        }
    }

    public void solve()
    {
        for (int i = 0; i < maxSize; i++)
        {
            traverseAt(i);
        }
    }

    private void traverseAt(int origin)
    {
        stringSoFar.append(puzzle[origin]);
        used[origin] = true;

        //Check if we have a valid word
        if ((stringSoFar.length() >= Constants.MINIMUM_WORD_LENGTH) && (trie.containKey(stringSoFar.toString())))
        {
            logger.info("Found: " + stringSoFar.toString());
        }

        //Find where to go next
        for (int destination = 0; destination < maxSize; destination++)
        {
            if (matrix[origin][destination] && !used[destination] && trie.containPrefix(stringSoFar.toString() + puzzle[destination]))
            {
                traverseAt(destination);
            }
        }

        used[origin] = false;
        stringSoFar.deleteCharAt(stringSoFar.length() - 1);
    }

}

gineer.bogglesolver.trie.Node

package gineer.bogglesolver.trie;

import gineer.bogglesolver.util.Constants;

class Node
{
    Node[] children;
    boolean isKey;

    public Node()
    {
        isKey = false;
        children = new Node[Constants.NUMBER_LETTERS_IN_ALPHABET];
    }

    public Node(boolean key)
    {
        isKey = key;
        children = new Node[Constants.NUMBER_LETTERS_IN_ALPHABET];
    }

    /**
     Method to insert a string to Node and its children

     @param key the string to insert (the string is assumed to be uppercase)
     @return true if the node or one of its children is changed, false otherwise
     */
    public boolean insert(String key)
    {
        //If the key is empty, this node is a key
        if (key.length() == 0)
        {
            if (isKey)
                return false;
            else
            {
                isKey = true;
                return true;
            }
        }
        else
        {//otherwise, insert in one of its child

            int childNodePosition = key.charAt(0) - Constants.LETTER_A;
            if (children[childNodePosition] == null)
            {
                children[childNodePosition] = new Node();
                children[childNodePosition].insert(key.substring(1));
                return true;
            }
            else
            {
                return children[childNodePosition].insert(key.substring(1));
            }
        }
    }

    /**
     Returns whether key is a valid prefix for certain key in this trie.
     For example: if key "hello" is in this trie, tests with all prefixes "hel", "hell", "hello" return true

     @param prefix the prefix to check
     @return true if the prefix is valid, false otherwise
     */
    public boolean containPrefix(String prefix)
    {
        //If the prefix is empty, return true
        if (prefix.length() == 0)
        {
            return true;
        }
        else
        {//otherwise, check in one of its child
            int childNodePosition = prefix.charAt(0) - Constants.LETTER_A;
            return children[childNodePosition] != null && children[childNodePosition].containPrefix(prefix.substring(1));
        }
    }

    /**
     Returns whether key is a valid key in this trie.
     For example: if key "hello" is in this trie, tests with all prefixes "hel", "hell" return false

     @param key the key to check
     @return true if the key is valid, false otherwise
     */
    public boolean containKey(String key)
    {
        //If the prefix is empty, return true
        if (key.length() == 0)
        {
            return isKey;
        }
        else
        {//otherwise, check in one of its child
            int childNodePosition = key.charAt(0) - Constants.LETTER_A;
            return children[childNodePosition] != null && children[childNodePosition].containKey(key.substring(1));
        }
    }

    public boolean isKey()
    {
        return isKey;
    }

    public void setKey(boolean key)
    {
        isKey = key;
    }
}

gineer.bogglesolver.trie.Trie

package gineer.bogglesolver.trie;

public class Trie
{
    Node root;

    public Trie()
    {
        this.root = new Node();
    }

    /**
     Method to insert a string to Node and its children

     @param key the string to insert (the string is assumed to be uppercase)
     @return true if the node or one of its children is changed, false otherwise
     */
    public boolean insert(String key)
    {
        return root.insert(key.toUpperCase());
    }

    /**
     Returns whether key is a valid prefix for certain key in this trie.
     For example: if key "hello" is in this trie, tests with all prefixes "hel", "hell", "hello" return true

     @param prefix the prefix to check
     @return true if the prefix is valid, false otherwise
     */
    public boolean containPrefix(String prefix)
    {
        return root.containPrefix(prefix.toUpperCase());
    }

    /**
     Returns whether key is a valid key in this trie.
     For example: if key "hello" is in this trie, tests with all prefixes "hel", "hell" return false

     @param key the key to check
     @return true if the key is valid, false otherwise
     */
    public boolean containKey(String key)
    {
        return root.containKey(key.toUpperCase());
    }


}

gineer.bogglesolver.util.Constants

package gineer.bogglesolver.util;

public class Constants
{

    public static final int NUMBER_LETTERS_IN_ALPHABET = 26;
    public static final char LETTER_A = 'A';
    public static final int MINIMUM_WORD_LENGTH = 3;
    public static final int DEFAULT_PUZZLE_SIZE = 4;
}

gineer.bogglesolver.util.Util

package gineer.bogglesolver.util;

import gineer.bogglesolver.trie.Trie;
import org.apache.log4j.Logger;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Util
{
    private final static Logger logger = Logger.getLogger(Util.class);
    private static Trie trie;
    private static int size = Constants.DEFAULT_PUZZLE_SIZE;

    /**
     Returns the trie built from the dictionary.  The size is used to eliminate words that are too long.

     @param size the size of puzzle.  The maximum lenght of words in the returned trie is (size * size)
     @return the trie that can be used for puzzle of that size
     */
    public static Trie getTrie(int size)
    {
        if ((trie != null) && size == Util.size)
            return trie;

        trie = new Trie();
        Util.size = size;

        logger.info("Reading the dictionary");
        final File file = new File("dictionary.txt");
        try
        {
            Scanner scanner = new Scanner(file);
            final int maxSize = size * size;
            while (scanner.hasNext())
            {
                String line = scanner.nextLine().replaceAll("[^\\p{Alpha}]", "");

                if (line.length() <= maxSize)
                    trie.insert(line);
            }
        }
        catch (FileNotFoundException e)
        {
            logger.error("Cannot open file", e);
        }

        logger.info("Finish reading the dictionary");
        return trie;
    }

    static boolean[] connectivityRow(int x, int y, int size)
    {
        boolean[] squares = new boolean[size * size];
        for (int offsetX = -1; offsetX <= 1; offsetX++)
        {
            for (int offsetY = -1; offsetY <= 1; offsetY++)
            {
                final int calX = x + offsetX;
                final int calY = y + offsetY;
                if ((calX >= 0) && (calX < size) && (calY >= 0) && (calY < size))
                    squares[calY * size + calX] = true;
            }
        }

        squares[y * size + x] = false;//the current x, y is false

        return squares;
    }

    /**
     Returns the matrix of connectivity between two points.  Point i can go to point j iff matrix[i][j] is true
     Square (x, y) is equivalent to point (size * y + x).  For example, square (1,1) is point 5 in a puzzle of size 4

     @param size the size of the puzzle
     @return the connectivity matrix
     */
    public static boolean[][] connectivityMatrix(int size)
    {
        boolean[][] matrix = new boolean[size * size][];
        for (int x = 0; x < size; x++)
        {
            for (int y = 0; y < size; y++)
            {
                matrix[y * size + x] = connectivityRow(x, y, size);
            }
        }
        return matrix;
    }
}
23
1.07.2009 03:03:12
Я сравнивал свои выходные данные с выходными данными других StackOverflowers, и кажется, что в выходных данных Адама, Джона и Рварчера не хватает некоторых слов. Например, «Mwa» есть в словаре (да!), Но он не возвращается в выходных данных от Адама, Джона и rvarcher. Он возвращается дважды в PHP-ссылке Паоло.
gineer 1.07.2009 08:04:02
Я попробовал это, скопировав его. Там написано "Чтение ..." и "Завершить чтение ...", но после этого ничего не появляется. Нет совпадений отображаются.
MikkoP 11.11.2012 19:02:26

Я знаю, что я опоздал, но я сделал это некоторое время назад в PHP - просто для удовольствия ...

http://www.lostsockdesign.com.au/sandbox/boggle/index.php?letters=fxieamloewbxastu Найдено 75 слов (133 балла ) за 0,90108 секунд

F.........X..I..............E............... A......................................M..............................L............................O............................... E....................W............................B..........................X A..................S..................................................T.................U....

Дает некоторое представление о том, что на самом деле делает программа - каждая буква - это то место, где она начинает просматривать шаблоны, а каждая '.' показывает путь, который он пытался пройти. Чем больше '.' есть дальнейшие его поиски.

Дайте мне знать, если вам нужен код ... это ужасное сочетание PHP и HTML, которое никогда не предназначалось для того, чтобы увидеть свет, поэтому я не осмелюсь опубликовать его здесь: P

9
7.10.2009 12:59:10

Я потратил 3 месяца, работая над решением проблемы 10x5 Boggle с 10 лучшими точками.

Проблема теперь решена и выложена с полным раскрытием на 5 веб страницах. Пожалуйста, свяжитесь со мной с вопросами.

Алгоритм анализа доски использует явный стек для псевдорекурсивного обхода квадратов доски через направленный ациклический граф слов с прямой дочерней информацией и механизмом отслеживания меток времени. Вполне возможно, это самая передовая в мире структура данных лексикона.

Схема оценивает около 10 000 очень хороших плат в секунду на четырехъядерном ядре. (9500+ баллов)

Родительская веб-страница:

DeepSearch.c - http://www.pathcom.com/~vadco/deep.html

Веб-страницы компонентов:

Оптимальное табло - http://www.pathcom.com/~vadco/binary.html

Усовершенствованная структура лексики - http://www.pathcom.com/~vadco/adtdawg.html

Алгоритм анализа форума - http://www.pathcom.com/~vadco/guns.html

Параллельная пакетная обработка - http://www.pathcom.com/~vadco/parallel.html

- Эта комплексная работа будет интересна только человеку, который требует самого лучшего.

9
27.01.2012 06:03:39
Ваш анализ интересен, но технически результаты не являются ошибочными. Игра 5x5 включает в себя один кубик, который содержит лица BJKQXZ, ваша реализация явно исключает все эти буквы, поэтому в реальной игре Boggle положение доски фактически невозможно.
MarkPflug 25.01.2012 00:43:59

Я понимаю, что время этого вопроса пришло и ушло, но так как я сам работал над решателем и наткнулся на это, пока гуглял, я подумал, что должен опубликовать ссылку на свою, так как она кажется немного отличной от некоторых других.

Я решил использовать плоский массив для игровой доски и выполнять рекурсивные поиски для каждой буквы на доске, переходя от действительного соседа к действительному соседу, расширяя поиск, если текущий список букв является действительным префиксом в индексе. При прохождении понятия текущего слова используется список индексов на доске, а не буквы, составляющие слово. При проверке индекса индексы переводятся в буквы и проверка завершена.

Индекс представляет собой словарь грубой силы, который немного похож на три, но допускает Pythonic запросы индекса. Если в списке есть слова «кошка» и «кошка», вы получите это в словаре:

   d = { 'c': ['cat','cater'],
     'ca': ['cat','cater'],
     'cat': ['cat','cater'],
     'cate': ['cater'],
     'cater': ['cater'],
   }

Таким образом, если current_word равно 'ca', вы знаете, что это действительный префикс, потому что 'ca' in dвозвращает True (поэтому продолжайте обход доски). И если current_word - это 'cat', то вы знаете, что это правильное слово, потому что оно является действительным префиксом и 'cat' in d['cat']тоже возвращает True.

Если это чувствуется, то допускается некоторый читаемый код, который не кажется слишком медленным. Как и все остальные, затраты в этой системе на чтение / построение индекса. Решение платы довольно много шума.

Код находится по адресу http://gist.github.com/268079 . Он намеренно вертикальный и наивный с множеством явных проверок достоверности, потому что я хотел понять проблему, не прибегая к ней с кучей магии или неизвестности.

3
3.01.2010 19:04:29

Просто ради интереса я реализовал один в bash. Это не супер быстро, но разумно.

http://dev.xkyle.com/bashboggle/

4
24.08.2010 04:12:00

Я реализовал решение в OCaml . Он предварительно компилирует словарь как три и использует частоты двухбуквенных последовательностей, чтобы исключить края, которые никогда не могли бы появиться в слове, чтобы ускорить обработку.

Он решает ваш пример платы за 0,35 мс (с дополнительным временем запуска 6 мс, которое в основном связано с загрузкой дерева в память).

Найденные решения:

["swami"; "emile"; "limbs"; "limbo"; "limes"; "amble"; "tubs"; "stub";
 "swam"; "semi"; "seam"; "awes"; "buts"; "bole"; "boil"; "west"; "east";
 "emil"; "lobs"; "limb"; "lime"; "lima"; "mesa"; "mews"; "mewl"; "maws";
 "milo"; "mile"; "awes"; "amie"; "axle"; "elma"; "fame"; "ubs"; "tux"; "tub";
 "twa"; "twa"; "stu"; "saw"; "sea"; "sew"; "sea"; "awe"; "awl"; "but"; "btu";
 "box"; "bmw"; "was"; "wax"; "oil"; "lox"; "lob"; "leo"; "lei"; "lie"; "mes";
 "mew"; "mae"; "maw"; "max"; "mil"; "mix"; "awe"; "awl"; "elm"; "eli"; "fax"]
1
13.05.2012 12:01:07
Это хорошо, но все время, опубликованное здесь, включает в себя любое время «запуска» для загрузки словаря в память, поэтому сравнение 0,35 с другим временем довольно далеко от точности. Кроме того, вы используете другой словарь? Вам не хватает некоторых слов. В любом случае, +1
Paolo Bergantino 13.05.2012 16:40:00
Время запуска занимает 6 мс, поэтому вы смотрите на 6,35 мс для полного запуска. Я использую свой локальный /usr/share/dictсловарь, и некоторые слова действительно отсутствуют (например, EMBOLE).
Victor Nicollet 14.05.2012 12:00:52

Вот моя реализация Java: https://github.com/zouzhile/interview/blob/master/src/com/interview/algorithms/tree/BoggleSolver.java

Построение Trie заняло 0 часов, 0 минут, 1 секунда, 532 миллисекунды
Поиск слова занял 0 часов, 0 минут, 0 секунд, 92 миллисекунды

eel eeler eely eer eke eker eld eleut elk ell 
elle epee epihippus ere erept err error erupt eurus eye 
eyer eyey hip hipe hiper hippish hipple hippus his hish 
hiss hist hler hsi ihi iphis isis issue issuer ist 
isurus kee keek keeker keel keeler keep keeper keld kele 
kelek kelep kelk kell kelly kelp kelper kep kepi kept 
ker kerel kern keup keuper key kyl kyle lee leek 
leeky leep leer lek leo leper leptus lepus ler leu 
ley lleu lue lull luller lulu lunn lunt lunule luo 
lupe lupis lupulus lupus lur lure lurer lush lushly lust 
lustrous lut lye nul null nun nupe nurture nurturer nut 
oer ore ort ouphish our oust out outpeep outpeer outpipe 
outpull outpush output outre outrun outrush outspell outspue outspurn outspurt 
outstrut outstunt outsulk outturn outusure oyer pee peek peel peele 
peeler peeoy peep peeper peepeye peer pele peleus pell peller 
pelu pep peplus pepper pepperer pepsis per pern pert pertussis 
peru perule perun peul phi pip pipe piper pipi pipistrel 
pipistrelle pipistrellus pipper pish piss pist plup plus plush ply 
plyer psi pst puerer pul pule puler pulk pull puller 
pulley pullus pulp pulper pulu puly pun punt pup puppis 
pur pure puree purely purer purr purre purree purrel purrer 
puru purupuru pus push puss pustule put putt puture ree 
reek reeker reeky reel reeler reeper rel rely reoutput rep 
repel repeller repipe reply repp reps reree rereel rerun reuel 
roe roer roey roue rouelle roun roup rouper roust rout 
roy rue ruelle ruer rule ruler rull ruller run runt 
rupee rupert rupture ruru rus rush russ rust rustre rut 
shi shih ship shipper shish shlu sip sipe siper sipper 
sis sish sisi siss sissu sist sistrurus speel speer spelk 
spell speller splurt spun spur spurn spurrer spurt sput ssi 
ssu stre stree streek streel streeler streep streke streperous strepsis 
strey stroup stroy stroyer strue strunt strut stu stue stull 
stuller stun stunt stupe stupeous stupp sturnus sturt stuss stut 
sue suer suerre suld sulk sulker sulky sull sully sulu 
sun sunn sunt sunup sup supe super superoutput supper supple 
supplely supply sur sure surely surrey sus susi susu susurr 
susurrous susurrus sutu suture suu tree treey trek trekker trey 
troupe trouper trout troy true truer trull truller truly trun 
trush truss trust tshi tst tsun tsutsutsi tue tule tulle 
tulu tun tunu tup tupek tupi tur turn turnup turr 
turus tush tussis tussur tut tuts tutu tutulus ule ull 
uller ulu ululu unreel unrule unruly unrun unrust untrue untruly 
untruss untrust unturn unurn upper upperer uppish uppishly uppull uppush 
upspurt upsun upsup uptree uptruss upturn ure urn uro uru 
urus urushi ush ust usun usure usurer utu yee yeel 
yeld yelk yell yeller yelp yelper yeo yep yer yere 
yern yoe yor yore you youl youp your yourn yoy 

Примечание: я использовал словарь и матрицу символов в начале этой темы. Код был запущен на моем MacBookPro, ниже приведена некоторая информация о машине.

Название модели: MacBook Pro
Идентификатор модели: MacBookPro8,1
Имя процессора: Intel Core i5
Частота процессора: 2,3 ГГц
Количество процессоров: 1
Общее количество ядер: 2
Кэш- память L2 (на ядро): 256 КБ
Кэш-
память L3: 3 МБ Память: 4
Версия загрузочного ПЗУ GB : MBP81.0047.B0E
Версия SMC (система): 1.68f96

0
1.11.2012 08:14:34

Я думаю, что вы, вероятно, потратите большую часть своего времени, пытаясь сопоставить слова, которые не могут быть построены вашей сеткой букв. Итак, первое, что я хотел бы сделать, это попытаться ускорить этот шаг, и это поможет вам пройти большую часть пути.

Для этого я бы повторно выразил сетку в виде таблицы возможных «ходов», которые вы индексируете с помощью буквы-перехода, на которую вы смотрите.

Начните с присвоения каждой букве числа из всего вашего алфавита (A = 0, B = 1, C = 2, ... и т. Д.).

Давайте возьмем этот пример:

h b c d
e e g h
l l k l
m o f p

А пока давайте используем алфавит букв, которые у нас есть (обычно вы, вероятно, захотите использовать один и тот же целый алфавит каждый раз):

 b | c | d | e | f | g | h | k | l | m |  o |  p
---+---+---+---+---+---+---+---+---+---+----+----
 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11

Затем вы создаете двумерный логический массив, который сообщает о наличии определенного перехода букв:

     |  0  1  2  3  4  5  6  7  8  9 10 11  <- from letter
     |  b  c  d  e  f  g  h  k  l  m  o  p
-----+--------------------------------------
 0 b |     T     T     T  T     
 1 c |  T     T  T     T  T
 2 d |     T           T  T
 3 e |  T  T     T     T  T  T  T
 4 f |                       T  T     T  T
 5 g |  T  T  T  T        T  T  T
 6 h |  T  T  T  T     T     T  T
 7 k |           T  T  T  T     T     T  T
 8 l |           T  T  T  T  T  T  T  T  T
 9 m |                          T     T
10 o |              T        T  T  T
11 p |              T        T  T
 ^
 to letter

Теперь просмотрите ваш список слов и преобразуйте слова в переходы:

hello (6, 3, 8, 8, 10):
6 -> 3, 3 -> 8, 8 -> 8, 8 -> 10

Затем проверьте, разрешены ли эти переходы, посмотрев их в вашей таблице:

[6][ 3] : T
[3][ 8] : T
[8][ 8] : T
[8][10] : T

Если им всем позволено, есть шанс, что это слово может быть найдено.

Например, слово «шлем» может быть исключено при 4-м переходе (от m до e: helMEt), поскольку эта запись в вашей таблице является ложной.

И слово хомяк может быть исключено, так как первый (h к a) переход не разрешен (даже не существует в вашей таблице).

Теперь, возможно, для очень немногих оставшихся слов, которые вы не исключили, попробуйте найти их в сетке так, как вы это делаете сейчас, или как предложено в некоторых других ответах здесь. Это сделано для того, чтобы избежать ложных срабатываний, возникающих в результате скачков между одинаковыми буквами в вашей сетке. Например, слово «помощь» разрешено таблицей, но не сеткой.

Некоторые дополнительные советы по улучшению производительности по этой идее:

  1. Вместо использования двумерного массива, используйте одномерный массив и просто рассчитайте индекс второй буквы самостоятельно. Таким образом, вместо массива 12x12, как описано выше, создайте одномерный массив длиной 144. Если вы всегда используете один и тот же алфавит (то есть массив 26x26 = 676x1 для стандартного английского алфавита), даже если не все буквы отображаются в вашей сетке Вы можете предварительно вычислить индексы в этом одномерном массиве, который вам нужно проверить, чтобы соответствовать вашим словарным словам. Например, индексы для «привет» в приведенном выше примере будут

    hello (6, 3, 8, 8, 10):
    42 (from 6 + 3x12), 99, 104, 128
    -> "hello" will be stored as 42, 99, 104, 128 in the dictionary
    
  2. Расширьте идею до трехмерной таблицы (представленной в виде одномерного массива), т.е. все разрешенные трехбуквенные комбинации. Таким образом, вы можете сразу исключить еще больше слов и сократить количество поисков в массиве для каждого слова на 1: для «привет» вам нужно только 3 поиска в массивах: hel, ell, llo. Кстати, будет очень быстро построить эту таблицу, поскольку в вашей сетке есть только 400 возможных 3-буквенных ходов.

  3. Предварительно рассчитайте индексы ходов в вашей сетке, которые вам нужно включить в вашу таблицу. Для приведенного выше примера вам необходимо установить для следующих записей значение «True»:

    (0,0) (0,1) -> here: h, b : [6][0]
    (0,0) (1,0) -> here: h, e : [6][3]
    (0,0) (1,1) -> here: h, e : [6][3]
    (0,1) (0,0) -> here: b, h : [0][6]
    (0,1) (0,2) -> here: b, c : [0][1]
    .
    :
    
  4. Также представьте свою игровую сетку в одномерном массиве с 16 записями, и таблица, предварительно рассчитанная в 3., содержит индексы в этом массиве.

Я уверен, что если вы воспользуетесь этим подходом, вы сможете заставить свой код работать безумно быстро, если у вас есть предварительно вычисленный словарь и уже загруженный в память.

Кстати, еще одна приятная вещь, если вы создаете игру, это запускать подобные вещи немедленно в фоновом режиме. Начните генерировать и решать первую игру, пока пользователь все еще смотрит на титульный экран в вашем приложении и вводит палец в положение, чтобы нажать «Play». Затем создайте и решите следующую игру, когда пользователь играет в предыдущую. Это должно дать вам много времени для запуска вашего кода.

(Мне нравится эта проблема, поэтому я, вероятно, буду испытывать желание реализовать свое предложение на Java в ближайшие дни, чтобы посмотреть, как оно на самом деле будет работать ... Я опубликую здесь код, как только это сделаю.)

ОБНОВИТЬ:

Хорошо, у меня было немного времени сегодня и я реализовал эту идею на Java:

class DictionaryEntry {
  public int[] letters;
  public int[] triplets;
}

class BoggleSolver {

  // Constants
  final int ALPHABET_SIZE = 5;  // up to 2^5 = 32 letters
  final int BOARD_SIZE    = 4;  // 4x4 board
  final int[] moves = {-BOARD_SIZE-1, -BOARD_SIZE, -BOARD_SIZE+1, 
                                  -1,                         +1,
                       +BOARD_SIZE-1, +BOARD_SIZE, +BOARD_SIZE+1};


  // Technically constant (calculated here for flexibility, but should be fixed)
  DictionaryEntry[] dictionary; // Processed word list
  int maxWordLength = 0;
  int[] boardTripletIndices; // List of all 3-letter moves in board coordinates

  DictionaryEntry[] buildDictionary(String fileName) throws IOException {
    BufferedReader fileReader = new BufferedReader(new FileReader(fileName));
    String word = fileReader.readLine();
    ArrayList<DictionaryEntry> result = new ArrayList<DictionaryEntry>();
    while (word!=null) {
      if (word.length()>=3) {
        word = word.toUpperCase();
        if (word.length()>maxWordLength) maxWordLength = word.length();
        DictionaryEntry entry = new DictionaryEntry();
        entry.letters  = new int[word.length()  ];
        entry.triplets = new int[word.length()-2];
        int i=0;
        for (char letter: word.toCharArray()) {
          entry.letters[i] = (byte) letter - 65; // Convert ASCII to 0..25
          if (i>=2)
            entry.triplets[i-2] = (((entry.letters[i-2]  << ALPHABET_SIZE) +
                                     entry.letters[i-1]) << ALPHABET_SIZE) +
                                     entry.letters[i];
          i++;
        }
        result.add(entry);
      }
      word = fileReader.readLine();
    }
    return result.toArray(new DictionaryEntry[result.size()]);
  }

  boolean isWrap(int a, int b) { // Checks if move a->b wraps board edge (like 3->4)
    return Math.abs(a%BOARD_SIZE-b%BOARD_SIZE)>1;
  }

  int[] buildTripletIndices() {
    ArrayList<Integer> result = new ArrayList<Integer>();
    for (int a=0; a<BOARD_SIZE*BOARD_SIZE; a++)
      for (int bm: moves) {
        int b=a+bm;
        if ((b>=0) && (b<board.length) && !isWrap(a, b))
          for (int cm: moves) {
            int c=b+cm;
            if ((c>=0) && (c<board.length) && (c!=a) && !isWrap(b, c)) {
              result.add(a);
              result.add(b);
              result.add(c);
            }
          }
      }
    int[] result2 = new int[result.size()];
    int i=0;
    for (Integer r: result) result2[i++] = r;
    return result2;
  }


  // Variables that depend on the actual game layout
  int[] board = new int[BOARD_SIZE*BOARD_SIZE]; // Letters in board
  boolean[] possibleTriplets = new boolean[1 << (ALPHABET_SIZE*3)];

  DictionaryEntry[] candidateWords;
  int candidateCount;

  int[] usedBoardPositions;

  DictionaryEntry[] foundWords;
  int foundCount;

  void initializeBoard(String[] letters) {
    for (int row=0; row<BOARD_SIZE; row++)
      for (int col=0; col<BOARD_SIZE; col++)
        board[row*BOARD_SIZE + col] = (byte) letters[row].charAt(col) - 65;
  }

  void setPossibleTriplets() {
    Arrays.fill(possibleTriplets, false); // Reset list
    int i=0;
    while (i<boardTripletIndices.length) {
      int triplet = (((board[boardTripletIndices[i++]]  << ALPHABET_SIZE) +
                       board[boardTripletIndices[i++]]) << ALPHABET_SIZE) +
                       board[boardTripletIndices[i++]];
      possibleTriplets[triplet] = true; 
    }
  }

  void checkWordTriplets() {
    candidateCount = 0;
    for (DictionaryEntry entry: dictionary) {
      boolean ok = true;
      int len = entry.triplets.length;
      for (int t=0; (t<len) && ok; t++)
        ok = possibleTriplets[entry.triplets[t]];
      if (ok) candidateWords[candidateCount++] = entry;
    }
  }

  void checkWords() { // Can probably be optimized a lot
    foundCount = 0;
    for (int i=0; i<candidateCount; i++) {
      DictionaryEntry candidate = candidateWords[i];
      for (int j=0; j<board.length; j++)
        if (board[j]==candidate.letters[0]) { 
          usedBoardPositions[0] = j;
          if (checkNextLetters(candidate, 1, j)) {
            foundWords[foundCount++] = candidate;
            break;
          }
        }
    }
  }

  boolean checkNextLetters(DictionaryEntry candidate, int letter, int pos) {
    if (letter==candidate.letters.length) return true;
    int match = candidate.letters[letter];
    for (int move: moves) {
      int next=pos+move;
      if ((next>=0) && (next<board.length) && (board[next]==match) && !isWrap(pos, next)) {
        boolean ok = true;
        for (int i=0; (i<letter) && ok; i++)
          ok = usedBoardPositions[i]!=next;
        if (ok) {
          usedBoardPositions[letter] = next;
          if (checkNextLetters(candidate, letter+1, next)) return true;
        }
      }
    }   
    return false;
  }


  // Just some helper functions
  String formatTime(long start, long end, long repetitions) {
    long time = (end-start)/repetitions;
    return time/1000000 + "." + (time/100000) % 10 + "" + (time/10000) % 10 + "ms";
  }

  String getWord(DictionaryEntry entry) {
    char[] result = new char[entry.letters.length];
    int i=0;
    for (int letter: entry.letters)
      result[i++] = (char) (letter+97);
    return new String(result);
  }

  void run() throws IOException {
    long start = System.nanoTime();

    // The following can be pre-computed and should be replaced by constants
    dictionary = buildDictionary("C:/TWL06.txt");
    boardTripletIndices = buildTripletIndices();
    long precomputed = System.nanoTime();


    // The following only needs to run once at the beginning of the program
    candidateWords     = new DictionaryEntry[dictionary.length]; // WAAAY too generous
    foundWords         = new DictionaryEntry[dictionary.length]; // WAAAY too generous
    usedBoardPositions = new int[maxWordLength];
    long initialized = System.nanoTime(); 

    for (int n=1; n<=100; n++) {
      // The following needs to run again for every new board
      initializeBoard(new String[] {"DGHI",
                                    "KLPS",
                                    "YEUT",
                                    "EORN"});
      setPossibleTriplets();
      checkWordTriplets();
      checkWords();
    }
    long solved = System.nanoTime();


    // Print out result and statistics
    System.out.println("Precomputation finished in " + formatTime(start, precomputed, 1)+":");
    System.out.println("  Words in the dictionary: "+dictionary.length);
    System.out.println("  Longest word:            "+maxWordLength+" letters");
    System.out.println("  Number of triplet-moves: "+boardTripletIndices.length/3);
    System.out.println();

    System.out.println("Initialization finished in " + formatTime(precomputed, initialized, 1));
    System.out.println();

    System.out.println("Board solved in "+formatTime(initialized, solved, 100)+":");
    System.out.println("  Number of candidates: "+candidateCount);
    System.out.println("  Number of actual words: "+foundCount);
    System.out.println();

    System.out.println("Words found:");
    int w=0;
    System.out.print("  ");
    for (int i=0; i<foundCount; i++) {
      System.out.print(getWord(foundWords[i]));
      w++;
      if (w==10) {
        w=0;
        System.out.println(); System.out.print("  ");
      } else
        if (i<foundCount-1) System.out.print(", ");
    }
    System.out.println();
  }

  public static void main(String[] args) throws IOException {
    new BoggleSolver().run();
  }
}

Вот некоторые результаты:

Для сетки из картинки, размещенной в оригинальном вопросе (DGHI ...):

Precomputation finished in 239.59ms:
  Words in the dictionary: 178590
  Longest word:            15 letters
  Number of triplet-moves: 408

Initialization finished in 0.22ms

Board solved in 3.70ms:
  Number of candidates: 230
  Number of actual words: 163 

Words found:
  eek, eel, eely, eld, elhi, elk, ern, erupt, erupts, euro
  eye, eyer, ghi, ghis, glee, gley, glue, gluer, gluey, glut
  gluts, hip, hiply, hips, his, hist, kelp, kelps, kep, kepi
  kepis, keps, kept, kern, key, kye, lee, lek, lept, leu
  ley, lunt, lunts, lure, lush, lust, lustre, lye, nus, nut
  nuts, ore, ort, orts, ouph, ouphs, our, oust, out, outre
  outs, oyer, pee, per, pert, phi, phis, pis, pish, plus
  plush, ply, plyer, psi, pst, pul, pule, puler, pun, punt
  punts, pur, pure, puree, purely, pus, push, put, puts, ree
  rely, rep, reply, reps, roe, roue, roup, roups, roust, rout
  routs, rue, rule, ruly, run, runt, runts, rupee, rush, rust
  rut, ruts, ship, shlep, sip, sipe, spue, spun, spur, spurn
  spurt, strep, stroy, stun, stupe, sue, suer, sulk, sulker, sulky
  sun, sup, supe, super, sure, surely, tree, trek, trey, troupe
  troy, true, truly, tule, tun, tup, tups, turn, tush, ups
  urn, uts, yeld, yelk, yelp, yelps, yep, yeps, yore, you
  your, yourn, yous

Для писем, опубликованных в качестве примера в оригинальном вопросе (FXIE ...)

Precomputation finished in 239.68ms:
  Words in the dictionary: 178590
  Longest word:            15 letters
  Number of triplet-moves: 408

Initialization finished in 0.21ms

Board solved in 3.69ms:
  Number of candidates: 87
  Number of actual words: 76

Words found:
  amble, ambo, ami, amie, asea, awa, awe, awes, awl, axil
  axile, axle, boil, bole, box, but, buts, east, elm, emboli
  fame, fames, fax, lei, lie, lima, limb, limbo, limbs, lime
  limes, lob, lobs, lox, mae, maes, maw, maws, max, maxi
  mesa, mew, mewl, mews, mil, mile, milo, mix, oil, ole
  sae, saw, sea, seam, semi, sew, stub, swam, swami, tub
  tubs, tux, twa, twae, twaes, twas, uts, wae, waes, wamble
  wame, wames, was, wast, wax, west

Для следующей 5x5-сетки:

R P R I T
A H H L N
I E T E P
Z R Y S G
O G W E Y

это дает это:

Precomputation finished in 240.39ms:
  Words in the dictionary: 178590
  Longest word:            15 letters
  Number of triplet-moves: 768

Initialization finished in 0.23ms

Board solved in 3.85ms:
  Number of candidates: 331
  Number of actual words: 240

Words found:
  aero, aery, ahi, air, airt, airth, airts, airy, ear, egest
  elhi, elint, erg, ergo, ester, eth, ether, eye, eyen, eyer
  eyes, eyre, eyrie, gel, gelt, gelts, gen, gent, gentil, gest
  geste, get, gets, gey, gor, gore, gory, grey, greyest, greys
  gyre, gyri, gyro, hae, haet, haets, hair, hairy, hap, harp
  heap, hear, heh, heir, help, helps, hen, hent, hep, her
  hero, hes, hest, het, hetero, heth, hets, hey, hie, hilt
  hilts, hin, hint, hire, hit, inlet, inlets, ire, leg, leges
  legs, lehr, lent, les, lest, let, lethe, lets, ley, leys
  lin, line, lines, liney, lint, lit, neg, negs, nest, nester
  net, nether, nets, nil, nit, ogre, ore, orgy, ort, orts
  pah, pair, par, peg, pegs, peh, pelt, pelter, peltry, pelts
  pen, pent, pes, pest, pester, pesty, pet, peter, pets, phi
  philter, 
23
20.05.2014 22:10:35
Хороший ответ. Я хотел бы видеть вашу реализацию в Java.
MikkoP 14.11.2012 12:47:27
@MikkoP Готово! :) Заняло около 3 часов и 220 строк кода. Хороший способ провести день. Дайте мне знать, если у вас есть какие-либо вопросы о том, как это работает ... :)
Markus A. 17.11.2012 02:14:45
Спасибо за размещение кода! Я попробовал это с моим собственным словарем после того, как я добавил отсутствующий импорт. Я получаю ArrayIndexOutOfBoundException на линии ok = possibleTriplets[entry.triplets[t]];. хмм?
MikkoP 17.11.2012 18:14:41
@MikkoP Этот код в настоящее время написан, чтобы предполагать, что словарь содержит только заглавные буквы AZ. Суть в строке 34: entry.letters[i] = (byte) letter - 65;она просто принимает значение ASCII и вычитает 65 («А»). Если в вашем словаре есть умляуты или строчные буквы, это даст значения больше 31, которые не планируются настройкой размера алфавита в строке 9. Для поддержки других букв вам придется расширить эту строку сопоставить их в диапазоне, разрешенном размером алфавита.
Markus A. 17.11.2012 19:25:09
@AlexanderN Вы, наверное, правильно понимаете логику. Я сделал ошибку, копируя сетку писем ... Извините ... (исправлено)
Markus A. 20.05.2014 22:11:21

Я решил это тоже с Java. Моя реализация имеет длину 269 строк и довольно проста в использовании. Сначала вам нужно создать новый экземпляр класса Boggler, а затем вызвать функцию решения с сеткой в ​​качестве параметра. Требуется около 100 мс, чтобы загрузить словарь из 50 000 слов на моем компьютере, и он находит слова примерно за 10-20 мс. Найденные слова сохраняются в ArrayList, foundWords.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Boggler {
    private ArrayList<String> words = new ArrayList<String>();      
    private ArrayList<String> roundWords = new ArrayList<String>(); 
    private ArrayList<Word> foundWords = new ArrayList<Word>();     
    private char[][] letterGrid = new char[4][4];                   
    private String letters;                                         

    public Boggler() throws FileNotFoundException, IOException, URISyntaxException {
        long startTime = System.currentTimeMillis();

        URL path = GUI.class.getResource("words.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(path.toURI()).getAbsolutePath()), "iso-8859-1"));
        String line;
        while((line = br.readLine()) != null) {
            if(line.length() < 3 || line.length() > 10) {
                continue;
            }

            this.words.add(line);
        }
    }

    public ArrayList<Word> getWords() {
        return this.foundWords;
    }

    public void solve(String letters) {
        this.letters = "";
        this.foundWords = new ArrayList<Word>();

        for(int i = 0; i < letters.length(); i++) {
            if(!this.letters.contains(letters.substring(i, i + 1))) {
                this.letters += letters.substring(i, i + 1);
            }
        }

        for(int i = 0; i < 4; i++) {
            for(int j = 0; j < 4; j++) {
                this.letterGrid[i][j] = letters.charAt(i * 4 + j);
            }
        }

        System.out.println(Arrays.deepToString(this.letterGrid));               

        this.roundWords = new ArrayList<String>();      
        String pattern = "[" + this.letters + "]+";     

        for(int i = 0; i < this.words.size(); i++) {

            if(this.words.get(i).matches(pattern)) {
                this.roundWords.add(this.words.get(i));
            }
        }

        for(int i = 0; i < this.roundWords.size(); i++) {
            Word word = checkForWord(this.roundWords.get(i));

            if(word != null) {
                System.out.println(word);
                this.foundWords.add(word);
            }
        }       
    }

    private Word checkForWord(String word) {
        char initial = word.charAt(0);
        ArrayList<LetterCoord> startPoints = new ArrayList<LetterCoord>();

        int x = 0;  
        int y = 0;
        for(char[] row: this.letterGrid) {
            x = 0;

            for(char letter: row) {
                if(initial == letter) {
                    startPoints.add(new LetterCoord(x, y));
                }

                x++;
            }

            y++;
        }

        ArrayList<LetterCoord> letterCoords = null;
        for(int initialTry = 0; initialTry < startPoints.size(); initialTry++) {
            letterCoords = new ArrayList<LetterCoord>();    

            x = startPoints.get(initialTry).getX(); 
            y = startPoints.get(initialTry).getY();

            LetterCoord initialCoord = new LetterCoord(x, y);
            letterCoords.add(initialCoord);

            letterLoop: for(int letterIndex = 1; letterIndex < word.length(); letterIndex++) {
                LetterCoord lastCoord = letterCoords.get(letterCoords.size() - 1);  
                char currentChar = word.charAt(letterIndex);                        

                ArrayList<LetterCoord> letterLocations = getNeighbours(currentChar, lastCoord.getX(), lastCoord.getY());

                if(letterLocations == null) {
                    return null;    
                }       

                for(int foundIndex = 0; foundIndex < letterLocations.size(); foundIndex++) {
                    if(letterIndex != word.length() - 1 && true == false) {
                        char nextChar = word.charAt(letterIndex + 1);
                        int lastX = letterCoords.get(letterCoords.size() - 1).getX();
                        int lastY = letterCoords.get(letterCoords.size() - 1).getY();

                        ArrayList<LetterCoord> possibleIndex = getNeighbours(nextChar, lastX, lastY);
                        if(possibleIndex != null) {
                            if(!letterCoords.contains(letterLocations.get(foundIndex))) {
                                letterCoords.add(letterLocations.get(foundIndex));
                            }
                            continue letterLoop;
                        } else {
                            return null;
                        }
                    } else {
                        if(!letterCoords.contains(letterLocations.get(foundIndex))) {
                            letterCoords.add(letterLocations.get(foundIndex));

                            continue letterLoop;
                        }
                    }
                }
            }

            if(letterCoords != null) {
                if(letterCoords.size() == word.length()) {
                    Word w = new Word(word);
                    w.addList(letterCoords);
                    return w;
                } else {
                    return null;
                }
            }
        }

        if(letterCoords != null) {
            Word foundWord = new Word(word);
            foundWord.addList(letterCoords);

            return foundWord;
        }

        return null;
    }

    public ArrayList<LetterCoord> getNeighbours(char letterToSearch, int x, int y) {
        ArrayList<LetterCoord> neighbours = new ArrayList<LetterCoord>();

        for(int _y = y - 1; _y <= y + 1; _y++) {
            for(int _x = x - 1; _x <= x + 1; _x++) {
                if(_x < 0 || _y < 0 || (_x == x && _y == y) || _y > 3 || _x > 3) {
                    continue;
                }

                if(this.letterGrid[_y][_x] == letterToSearch && !neighbours.contains(new LetterCoord(_x, _y))) {
                    neighbours.add(new LetterCoord(_x, _y));
                }
            }
        }

        if(neighbours.isEmpty()) {
            return null;
        } else {
            return neighbours;
        }
    }
}

class Word {
    private String word;    
    private ArrayList<LetterCoord> letterCoords = new ArrayList<LetterCoord>();

    public Word(String word) {
        this.word = word;
    }

    public boolean addCoords(int x, int y) {
        LetterCoord lc = new LetterCoord(x, y);

        if(!this.letterCoords.contains(lc)) {
            this.letterCoords.add(lc);

            return true;
        }

        return false;
    }

    public void addList(ArrayList<LetterCoord> letterCoords) {
        this.letterCoords = letterCoords;
    } 

    @Override
    public String toString() {
        String outputString = this.word + " ";
        for(int i = 0; i < letterCoords.size(); i++) {
            outputString += "(" + letterCoords.get(i).getX() + ", " + letterCoords.get(i).getY() + ") ";
        }

        return outputString;
    }

    public String getWord() {
        return this.word;
    }

    public ArrayList<LetterCoord> getList() {
        return this.letterCoords;
    }
}

class LetterCoord extends ArrayList {
    private int x;          
    private int y;          

    public LetterCoord(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return this.x;
    }

    public int getY() {
        return this.y;
    }

    @Override
    public boolean equals(Object o) {
        if(!(o instanceof LetterCoord)) {
            return false;
        }

        LetterCoord lc = (LetterCoord) o;

        if(this.x == lc.getX() &&
                this.y == lc.getY()) {
            return true;
        }

        return false;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 29 * hash + this.x;
        hash = 24 * hash + this.y;
        return hash;
    }
}
0
1.12.2012 13:48:23

Я решил это в с. Для запуска на моей машине требуется около 48 мс (примерно 98% времени уходит на загрузку словаря с диска и создание файла). Словарь это / usr / share / dict / american-english, в котором 62886 слов.

Исходный код

0
10.12.2012 22:56:06

Я решил это отлично и очень быстро. Я положил его в приложение для Android. Посмотрите видео по ссылке в магазине воспроизведения, чтобы увидеть его в действии.

Word Cheats - это приложение, которое "взламывает" любую игру в стиле матрицы. Это приложение было создано, чтобы помочь мне обмануть слово скремблер. Его можно использовать для поиска слов, разрыва слов, слов, поиска слов, взлома слов, изумления и многого другого!

Это можно увидеть здесь https://play.google.com/store/apps/details?id=com.harris.wordcracker

Просмотреть приложение в действии в видео https://www.youtube.com/watch?v=DL2974WmNAI

0
18.03.2013 23:47:52

Я написал свой решатель на C ++. Я реализовал пользовательскую древовидную структуру. Я не уверен, что это можно считать трий, но это похоже. Каждый узел имеет 26 ветвей, по 1 на каждую букву алфавита. Я пересекаю ветви доски переключателя параллельно с ветвями моего словаря. Если ветка отсутствует в словаре, я прекращаю поиск на доске Boggle. Я конвертирую все буквы на доске в целые. Так что «A» = 0. Поскольку это просто массивы, поиск всегда равен O (1). Каждый узел хранит, завершает ли он слово и сколько слов существует в его дочерних элементах. Дерево обрезается, так как слова найдены, чтобы уменьшить повторный поиск тех же слов. Я считаю, что обрезка также O (1).

Процессор: Pentium SU2700, 1,3 ГГц,
ОЗУ: 3 ГБ

Загружает словарь из 178 590 слов за <1 секунду.
Решает 100x100 Boggle (boggle.txt) за 4 секунды. ~ 44 000 слов найдено.
Решение 4x4 Boggle слишком быстро, чтобы обеспечить значимый тест. :)

Fast Boggle Solver GitHub Repo

3
16.04.2013 03:51:30

Я решил это в C #, используя алгоритм DFA. Вы можете проверить мой код на

https://github.com/attilabicsko/wordshuffler/

В дополнение к поиску слов в матрице, мой алгоритм сохраняет фактические пути для слов, поэтому для разработки игры поиска слов вы можете проверить, есть ли слово на реальном пути.

0
23.09.2013 07:49:19

Как насчет простой сортировки и использования двоичного поиска в словаре?

Возвращает весь список за 0,35 с и может быть дополнительно оптимизирован (например, путем удаления слов с неиспользованными буквами и т. Д.).

from bisect import bisect_left

f = open("dict.txt")
D.extend([line.strip() for line in f.readlines()])
D = sorted(D)

def neibs(M,x,y):
    n = len(M)
    for i in xrange(-1,2):
        for j in xrange(-1,2):
            if (i == 0 and j == 0) or (x + i < 0 or x + i >= n or y + j < 0 or y + j >= n):
                continue
            yield (x + i, y + j)

def findWords(M,D,x,y,prefix):
    prefix = prefix + M[x][y]

    # find word in dict by binary search
    found = bisect_left(D,prefix)

    # if found then yield
    if D[found] == prefix: 
        yield prefix

    # if what we found is not even a prefix then return
    # (there is no point in going further)
    if len(D[found]) < len(prefix) or D[found][:len(prefix)] != prefix:
        return

    # recourse
    for neib in neibs(M,x,y):
        for word in findWords(M,D,neib[0], neib[1], prefix):
            yield word

def solve(M,D):
    # check each starting point
    for x in xrange(0,len(M)):
        for y in xrange(0,len(M)):
            for word in findWords(M,D,x,y,""):
                yield word

grid = "fxie amlo ewbx astu".split()
print [x for x in solve(grid,D)]
0
6.01.2014 19:30:23
Я пробовал это, но. Сначала вы должны сказать, что D - это список. ... в противном случае вы получите ошибку. тогда я получаю "если D [найдено] == префикс: IndexError: список индекса вне диапазона". Я могу делать что-то не так. Python 2.7+
OWADVL 29.03.2015 19:49:39

Решение Node.JS JavaScript. Вычисляет все 100 уникальных слов менее чем за секунду, включая чтение файла словаря (MBA 2012).

Вывод:
["FAM", "TUX", "TUB", "FAE", "ELI", "ELM", "ELB", "TWA", "TWA", "SAW", "AMI", "SWA" , "SWA", "AME", "SEA", "SEW", "AES", "Шило", "AWE", "SEA", "АВВА", "MIX", "MIL", "АСТ",» ASE», "МАКС", "ДЕД", "MAW", "МЫ", "AWE", "МЭС", "Шило", "ЛОЖЬ", "LIM", "АВВА", "AES", "НО" , "BLO", "WAS", "ОФР", "WEA", "Лей", "LEO", " большие объекты", "LOX", "ОРЭ", "МАСЛО", "ОЛЙ", "WEA",» WAE», "ВОСК", "WAF","MILO", "ИСТ", "Wame", "ТВАС", "TWAE", "ЭМИЛЬ", "WEAM", "ОИМЭ", "AXIL", "WEST", "TWAE", "КОНЕЧНОСТЕЙ", "Wase », "WAST", "BLEO", "STUB", "испарения", "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ", "ныть", "ОСЬ", "FAME", "АЕС", "МИЛЯ", "AMIL", "Seax", "ШВА", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST », "AWEST", "Limax", "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать", "FAMBLE"]ВОСТОК», "Wame", "TWAS", "TWAE", "EMIL", "WEAM", "ОИМЭ", "AXIL", "WEST", "TWAE", "КОНЕЧНОСТЕЙ", "Wase", "WAST" , "BLEO", "STUB", "испарения", "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ", "ныть", "ОСЬ", "FAME", "АЕС",» МИЛЯ», "AMIL", "Seax", "ШВА", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "иноходью", "SWAMI", "AWEST", "AWEST" , "Limax", "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать", "FAMBLE"]ВОСТОК», "Wame", "TWAS", "TWAE", "EMIL", "WEAM", "ОИМЭ", "AXIL", "WEST", "TWAE", "КОНЕЧНОСТЕЙ", "Wase", "WAST" , "BLEO", "STUB", "испарения", "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ", "ныть", "ОСЬ", "FAME", "АЕС",» МИЛЯ», "AMIL", "Seax", "ШВА", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "иноходью", "SWAMI", "AWEST", "AWEST" , "Limax", "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать", "FAMBLE"]"TWAE", "ЭМИЛЬ", "WEAM", "ОИМЭ", "AXIL", "WEST", "TWAE", "КОНЕЧНОСТИ", "Wase", "WAST", "BLEO", "STUB", "испарения », "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ", "ныть", "ОСЬ", "FAME", "АЕС", "МИЛЯ", "AMIL", "Seax", "ШОВ", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба », "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачиваться", "FAMBLE"]"TWAE", "ЭМИЛЬ", "WEAM", "ОИМЭ", "AXIL", "WEST", "TWAE", "КОНЕЧНОСТИ", "Wase", "WAST", "BLEO", "STUB", "испарения », "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ", "ныть", "ОСЬ", "FAME", "АЕС", "МИЛЯ", "AMIL", "Seax", "ШОВ", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба », "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачиваться", "FAMBLE"]"WEST", "TWAE", "КОНЕЧНОСТИ", "Wase", "WAST", "BLEO", "STUB", "испарения", "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ », "ныть", "ОСЬ", "FAME", "АЕС", "МИЛЯ", "AMIL", "Seax", "ШВА", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать », "FAMBLE"]"WEST", "TWAE", "КОНЕЧНОСТИ", "Wase", "WAST", "BLEO", "STUB", "испарения", "Бола", "ЛАЙМ", "ССРВ", "ЛИМА", "МЕЗ », "ныть", "ОСЬ", "FAME", "АЕС", "МИЛЯ", "AMIL", "Seax", "ШВА", "SEMI", "поплыл", "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать », "FAMBLE"]ССРВ», "ЛИМА", "MESA", "ныть", "ОСЬ", "FAME", "ASEM", "МИЛЯ", "AMIL", "Seax", "ШВА", "SEMI", "поплыл" , "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба", "подвешенном", "EMBOX",» SEMBLE», "эмболия", "переворачиваться", "FAMBLE"]ССРВ», "ЛИМА", "MESA", "ныть", "ОСЬ", "FAME", "ASEM", "МИЛЯ", "AMIL", "Seax", "ШВА", "SEMI", "поплыл" , "AMBO", "AMLI", "AXILE", "Amble", "СВАМИ", "AWEST", "AWEST", "Limax", "LIMES", "лимба", "подвешенном", "EMBOX",» SEMBLE», "эмболия", "переворачиваться", "FAMBLE"]Limax», "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать", "FAMBLE"]Limax», "LIMES", "лимба", "подвешенном", "EMBOX", "SEMBLE", "эмболия", "переворачивать", "FAMBLE"]

Код:

var fs = require('fs')

var Node = function(value, row, col) {
    this.value = value
    this.row = row
    this.col = col
}

var Path = function() {
    this.nodes = []
}

Path.prototype.push = function(node) {
    this.nodes.push(node)
    return this
}

Path.prototype.contains = function(node) {
    for (var i = 0, ii = this.nodes.length; i < ii; i++) {
        if (this.nodes[i] === node) {
            return true
        }
    }

    return false
}

Path.prototype.clone = function() {
    var path = new Path()
    path.nodes = this.nodes.slice(0)
    return path
}

Path.prototype.to_word = function() {
    var word = ''

    for (var i = 0, ii = this.nodes.length; i < ii; ++i) {
        word += this.nodes[i].value
    }

    return word
}

var Board = function(nodes, dict) {
    // Expects n x m array.
    this.nodes = nodes
    this.words = []
    this.row_count = nodes.length
    this.col_count = nodes[0].length
    this.dict = dict
}

Board.from_raw = function(board, dict) {
    var ROW_COUNT = board.length
      , COL_COUNT = board[0].length

    var nodes = []

    // Replace board with Nodes
    for (var i = 0, ii = ROW_COUNT; i < ii; ++i) {
        nodes.push([])
        for (var j = 0, jj = COL_COUNT; j < jj; ++j) {
            nodes[i].push(new Node(board[i][j], i, j))
        }
    }

    return new Board(nodes, dict)
}

Board.prototype.toString = function() {
    return JSON.stringify(this.nodes)
}

Board.prototype.update_potential_words = function(dict) {
    for (var i = 0, ii = this.row_count; i < ii; ++i) {
        for (var j = 0, jj = this.col_count; j < jj; ++j) {
            var node = this.nodes[i][j]
              , path = new Path()

            path.push(node)

            this.dfs_search(path)
        }
    }
}

Board.prototype.on_board = function(row, col) {
    return 0 <= row && row < this.row_count && 0 <= col && col < this.col_count
}

Board.prototype.get_unsearched_neighbours = function(path) {
    var last_node = path.nodes[path.nodes.length - 1]

    var offsets = [
        [-1, -1], [-1,  0], [-1, +1]
      , [ 0, -1],           [ 0, +1]
      , [+1, -1], [+1,  0], [+1, +1]
    ]

    var neighbours = []

    for (var i = 0, ii = offsets.length; i < ii; ++i) {
        var offset = offsets[i]
        if (this.on_board(last_node.row + offset[0], last_node.col + offset[1])) {

            var potential_node = this.nodes[last_node.row + offset[0]][last_node.col + offset[1]]
            if (!path.contains(potential_node)) {
                // Create a new path if on board and we haven't visited this node yet.
                neighbours.push(potential_node)
            }
        }
    }

    return neighbours
}

Board.prototype.dfs_search = function(path) {
    var path_word = path.to_word()

    if (this.dict.contains_exact(path_word) && path_word.length >= 3) {
        this.words.push(path_word)
    }

    var neighbours = this.get_unsearched_neighbours(path)

    for (var i = 0, ii = neighbours.length; i < ii; ++i) {
        var neighbour = neighbours[i]
        var new_path = path.clone()
        new_path.push(neighbour)

        if (this.dict.contains_prefix(new_path.to_word())) {
            this.dfs_search(new_path)
        }
    }
}

var Dict = function() {
    this.dict_array = []

    var dict_data = fs.readFileSync('./web2', 'utf8')
    var dict_array = dict_data.split('\n')

    for (var i = 0, ii = dict_array.length; i < ii; ++i) {
        dict_array[i] = dict_array[i].toUpperCase()
    }

    this.dict_array = dict_array.sort()
}

Dict.prototype.contains_prefix = function(prefix) {
    // Binary search
    return this.search_prefix(prefix, 0, this.dict_array.length)
}

Dict.prototype.contains_exact = function(exact) {
    // Binary search
    return this.search_exact(exact, 0, this.dict_array.length)
}

Dict.prototype.search_prefix = function(prefix, start, end) {
    if (start >= end) {
        // If no more place to search, return no matter what.
        return this.dict_array[start].indexOf(prefix) > -1
    }

    var middle = Math.floor((start + end)/2)

    if (this.dict_array[middle].indexOf(prefix) > -1) {
        // If we prefix exists, return true.
        return true
    } else {
        // Recurse
        if (prefix <= this.dict_array[middle]) {
            return this.search_prefix(prefix, start, middle - 1)
        } else {
            return this.search_prefix(prefix, middle + 1, end)
        }
    }
}

Dict.prototype.search_exact = function(exact, start, end) {
    if (start >= end) {
        // If no more place to search, return no matter what.
        return this.dict_array[start] === exact
    }

    var middle = Math.floor((start + end)/2)

    if (this.dict_array[middle] === exact) {
        // If we prefix exists, return true.
        return true
    } else {
        // Recurse
        if (exact <= this.dict_array[middle]) {
            return this.search_exact(exact, start, middle - 1)
        } else {
            return this.search_exact(exact, middle + 1, end)
        }
    }
}

var board = [
    ['F', 'X', 'I', 'E']
  , ['A', 'M', 'L', 'O']
  , ['E', 'W', 'B', 'X']
  , ['A', 'S', 'T', 'U']
]

var dict = new Dict()

var b = Board.from_raw(board, dict)
b.update_potential_words()
console.log(JSON.stringify(b.words.sort(function(a, b) {
    return a.length - b.length
})))
1
16.10.2014 07:06:26
    package ProblemSolving;

import java.util.HashSet;
import java.util.Set;

/**
 * Given a 2-dimensional array of characters and a
 * dictionary in which a word can be searched in O(1) time.
 * Need to print all the words from array which are present
 * in dictionary. Word can be formed in any direction but
 * has to end at any edge of array.
 * (Need not worry much about the dictionary)
 */
public class DictionaryWord {
    private static char[][] matrix = new char[][]{
            {'a', 'f', 'h', 'u', 'n'},
            {'e', 't', 'a', 'i', 'r'},
            {'a', 'e', 'g', 'g', 'o'},
            {'t', 'r', 'm', 'l', 'p'}
    };
    private static int dim_x = matrix.length;
    private static int dim_y = matrix[matrix.length -1].length;
    private static Set<String> wordSet = new HashSet<String>();

    public static void main(String[] args) {
        //dictionary
        wordSet.add("after");
        wordSet.add("hate");
        wordSet.add("hair");
        wordSet.add("air");
        wordSet.add("eat");
        wordSet.add("tea");

        for (int x = 0; x < dim_x; x++) {
            for (int y = 0; y < dim_y; y++) {
                checkAndPrint(matrix[x][y] + "");
                int[][] visitedMap = new int[dim_x][dim_y];
                visitedMap[x][y] = 1;
                recursion(matrix[x][y] + "", visitedMap, x, y);
            }
        }
    }

    private static void checkAndPrint(String word) {
        if (wordSet.contains(word)) {
            System.out.println(word);
        }
    }

    private static void recursion(String word, int[][] visitedMap, int x, int y) {
        for (int i = Math.max(x - 1, 0); i < Math.min(x + 2, dim_x); i++) {
            for (int j = Math.max(y - 1, 0); j < Math.min(y + 2, dim_y); j++) {
                if (visitedMap[i][j] == 1) {
                    continue;
                } else {
                    int[][] newVisitedMap = new int[dim_x][dim_y];
                    for (int p = 0; p < dim_x; p++) {
                        for (int q = 0; q < dim_y; q++) {
                           newVisitedMap[p][q] = visitedMap[p][q];
                        }
                    }
                    newVisitedMap[i][j] = 1;
                    checkAndPrint(word + matrix[i][j]);
                    recursion(word + matrix[i][j], newVisitedMap, i, j);
                }
            }
        }
    }

}
0
1.12.2014 05:46:14

Для доски Boggle с N строками и M столбцами предположим следующее:

  • N * M значительно больше количества возможных слов
  • N * M значительно больше самого длинного слова

При этих предположениях сложность этого решения составляет O (N * M).

Я думаю, что сравнение времени работы этой единственной примерной платы во многих отношениях не имеет смысла, но для полноты картины это решение заканчивается на <0,2 с на моем современном MacBook Pro.

Это решение найдет все возможные пути для каждого слова в корпусе.

#!/usr/bin/env ruby
# Example usage: ./boggle-solver --board "fxie amlo ewbx astu"

autoload :Matrix, 'matrix'
autoload :OptionParser, 'optparse'

DEFAULT_CORPUS_PATH = '/usr/share/dict/words'.freeze

# Functions

def filter_corpus(matrix, corpus, min_word_length)
  board_char_counts = Hash.new(0)
  matrix.each { |c| board_char_counts[c] += 1 }

  max_word_length = matrix.row_count * matrix.column_count
  boggleable_regex = /^[#{board_char_counts.keys.reduce(:+)}]{#{min_word_length},#{max_word_length}}$/
  corpus.select{ |w| w.match boggleable_regex }.select do |w|
    word_char_counts = Hash.new(0)
    w.each_char { |c| word_char_counts[c] += 1 }
    word_char_counts.all? { |c, count| board_char_counts[c] >= count }
  end
end

def neighbors(point, matrix)
  i, j = point
  ([i-1, 0].max .. [i+1, matrix.row_count-1].min).inject([]) do |r, new_i|
    ([j-1, 0].max .. [j+1, matrix.column_count-1].min).inject(r) do |r, new_j|
      neighbor = [new_i, new_j]
      neighbor.eql?(point) ? r : r << neighbor
    end
  end
end

def expand_path(path, word, matrix)
  return [path] if path.length == word.length

  next_char = word[path.length]
  viable_neighbors = neighbors(path[-1], matrix).select do |point|
    !path.include?(point) && matrix.element(*point).eql?(next_char)
  end

  viable_neighbors.inject([]) do |result, point|
    result + expand_path(path.dup << point, word, matrix)
  end
end

def find_paths(word, matrix)
  result = []
  matrix.each_with_index do |c, i, j|
    result += expand_path([[i, j]], word, matrix) if c.eql?(word[0])
  end
  result
end

def solve(matrix, corpus, min_word_length: 3)
  boggleable_corpus = filter_corpus(matrix, corpus, min_word_length)
  boggleable_corpus.inject({}) do |result, w|
    paths = find_paths(w, matrix)
    result[w] = paths unless paths.empty?
    result
  end
end

# Script

options = { corpus_path: DEFAULT_CORPUS_PATH }
option_parser = OptionParser.new do |opts|
  opts.banner = 'Usage: boggle-solver --board <value> [--corpus <value>]'

  opts.on('--board BOARD', String, 'The board (e.g. "fxi aml ewb ast")') do |b|
    options[:board] = b
  end

  opts.on('--corpus CORPUS_PATH', String, 'Corpus file path') do |c|
    options[:corpus_path] = c
  end

  opts.on_tail('-h', '--help', 'Shows usage') do
    STDOUT.puts opts
    exit
  end
end
option_parser.parse!

unless options[:board]
  STDERR.puts option_parser
  exit false
end

unless File.file? options[:corpus_path]
  STDERR.puts "No corpus exists - #{options[:corpus_path]}"
  exit false
end

rows = options[:board].downcase.scan(/\S+/).map{ |row| row.scan(/./) }

raw_corpus = File.readlines(options[:corpus_path])
corpus = raw_corpus.map{ |w| w.downcase.rstrip }.uniq.sort

solution = solve(Matrix.rows(rows), corpus)
solution.each_pair do |w, paths|
  STDOUT.puts w
  paths.each do |path|
    STDOUT.puts "\t" + path.map{ |point| point.inspect }.join(', ')
  end
end
STDOUT.puts "TOTAL: #{solution.count}"
2
24.03.2015 06:54:00

Поэтому я хотел добавить еще один способ решения этой проблемы, так как все любят PHP. Я хотел бы провести небольшой рефакторинг, например, использовать сопоставление регулярных выражений для файла словаря, но сейчас я просто загружаю весь файл словаря в wordList.

Я сделал это, используя идею связанного списка. Каждый узел имеет символьное значение, значение местоположения и следующий указатель.

Значение местоположения - то, как я узнал, связаны ли два узла.

1     2     3     4
11    12    13    14
21    22    23    24
31    32    33    34

Таким образом, используя эту сетку, я знаю, что два узла соединены, если местоположение первого узла равно расположению вторых узлов +/- 1 для той же строки, +/- 9, 10, 11 для строки выше и ниже.

Я использую рекурсию для основного поиска. Он берет слово из wordList, находит все возможные начальные точки, а затем рекурсивно находит следующее возможное соединение, имея в виду, что он не может перейти в местоположение, которое он уже использует (именно поэтому я добавляю $ notInLoc).

В любом случае, я знаю, что он нуждается в некотором рефакторинге, и хотел бы услышать мысли о том, как сделать его чище, но он дает правильные результаты на основе файла словаря, который я использую. В зависимости от количества гласных и комбинаций на доске, это может занять от 3 до 6 секунд. Я знаю, что, как только я preg_match словарь результатов, это значительно уменьшится.

<?php
    ini_set('xdebug.var_display_max_depth', 20);
    ini_set('xdebug.var_display_max_children', 1024);
    ini_set('xdebug.var_display_max_data', 1024);

    class Node {
        var $loc;

        function __construct($value) {
            $this->value = $value;
            $next = null;
        }
    }

    class Boggle {
        var $root;
        var $locList = array (1, 2, 3, 4, 11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34);
        var $wordList = [];
        var $foundWords = [];

        function __construct($board) {
            // Takes in a board string and creates all the nodes
            $node = new Node($board[0]);
            $node->loc = $this->locList[0];
            $this->root = $node;
            for ($i = 1; $i < strlen($board); $i++) {
                    $node->next = new Node($board[$i]);
                    $node->next->loc = $this->locList[$i];
                    $node = $node->next;
            }
            // Load in a dictionary file
            // Use regexp to elimate all the words that could never appear and load the 
            // rest of the words into wordList
            $handle = fopen("dict.txt", "r");
            if ($handle) {
                while (($line = fgets($handle)) !== false) {
                    // process the line read.
                    $line = trim($line);
                    if (strlen($line) > 2) {
                        $this->wordList[] = trim($line);
                    }
                }
                fclose($handle);
            } else {
                // error opening the file.
                echo "Problem with the file.";
            } 
        }

        function isConnected($node1, $node2) {
        // Determines if 2 nodes are connected on the boggle board

            return (($node1->loc == $node2->loc + 1) || ($node1->loc == $node2->loc - 1) ||
               ($node1->loc == $node2->loc - 9) || ($node1->loc == $node2->loc - 10) || ($node1->loc == $node2->loc - 11) ||
               ($node1->loc == $node2->loc + 9) || ($node1->loc == $node2->loc + 10) || ($node1->loc == $node2->loc + 11)) ? true : false;

        }

        function find($value, $notInLoc = []) {
            // Returns a node with the value that isn't in a location
            $current = $this->root;
            while($current) {
                if ($current->value == $value && !in_array($current->loc, $notInLoc)) {
                    return $current;
                }
                if (isset($current->next)) {
                    $current = $current->next;
                } else {
                    break;
                }
            }
            return false;
        }

        function findAll($value) {
            // Returns an array of nodes with a specific value
            $current = $this->root;
            $foundNodes = [];
            while ($current) {
                if ($current->value == $value) {
                    $foundNodes[] = $current;
                }
                if (isset($current->next)) {
                    $current = $current->next;
                } else {
                    break;
                }
            }
            return (empty($foundNodes)) ? false : $foundNodes;
        }

        function findAllConnectedTo($node, $value, $notInLoc = []) {
            // Returns an array of nodes that are connected to a specific node and 
            // contain a specific value and are not in a certain location
            $nodeList = $this->findAll($value);
            $newList = [];
            if ($nodeList) {
                foreach ($nodeList as $node2) {
                    if (!in_array($node2->loc, $notInLoc) && $this->isConnected($node, $node2)) {
                        $newList[] = $node2;
                    }
                }
            }
            return (empty($newList)) ? false : $newList;
        }



        function inner($word, $list, $i = 0, $notInLoc = []) {
            $i++;
            foreach($list as $node) {
                $notInLoc[] = $node->loc;
                if ($list2 = $this->findAllConnectedTo($node, $word[$i], $notInLoc)) {
                    if ($i == (strlen($word) - 1)) {
                        return true;
                    } else {
                        return $this->inner($word, $list2, $i, $notInLoc);
                    }
                }
            }
            return false;
        }

        function findWord($word) {
            if ($list = $this->findAll($word[0])) {
                return $this->inner($word, $list);
            }
            return false;
        }

        function findAllWords() {
            foreach($this->wordList as $word) {
                if ($this->findWord($word)) {
                    $this->foundWords[] = $word;
                }
            }
        }

        function displayBoard() {
            $current = $this->root;
            for ($i=0; $i < 4; $i++) {
                echo $current->value . " " . $current->next->value . " " . $current->next->next->value . " " . $current->next->next->next->value . "<br />";
                if ($i < 3) {
                    $current = $current->next->next->next->next;
                }
            }
        }

    }

    function randomBoardString() {
        return substr(str_shuffle(str_repeat("abcdefghijklmnopqrstuvwxyz", 16)), 0, 16);
    }

    $myBoggle = new Boggle(randomBoardString());
    $myBoggle->displayBoard();
    $x = microtime(true);
    $myBoggle->findAllWords();
    $y = microtime(true);
    echo ($y-$x);
    var_dump($myBoggle->foundWords);

    ?>
1
20.08.2015 00:11:07