解决填字游戏[关闭]

Posted 2023-02-22

【中文标题】解决填字游戏[关闭]

【英文标题】：Solving crosswords efficiently [closed]

【发布时间】：2017-06-17 16:40:00

【问题描述】：

我有一个填字游戏和一个可以用来解决它的单词列表（单词可以放置多次，甚至一次也没有）。给定的填字游戏和单词列表总是有解决方案的。

我搜索了如何解决这个问题的线索，发现它是NP-Complete。我的最大填字游戏大小是 250 x 250，列表的最大长度（可以用来解决它的单词数量）是 200。我的目标是通过蛮力/回溯解决这种大小的填字游戏，这应该是可能的几秒钟（这是我的粗略估计，如果我错了，请纠正我）。

例如：

可用于解决填字游戏的给定单词列表：

可以 音乐 金枪鱼 你好

给定的空填字游戏（X为不可填字段，空字段需填写）：

解决办法：

现在我目前的方法是将填字游戏表示为二维数组并搜索空格（填字游戏上的 2 次迭代）。然后我根据单词的长度将单词匹配到空格，然后我尝试所有单词的组合到具有相同长度的空格。这种方法很快就变得非常混乱，我在尝试实现它时迷路了，有没有更优雅的解决方案？

【问题讨论】：

几秒钟对于这种大小的输入数据的暴力破解似乎有点乐观。回溯方法似乎比蛮力更好，但即使使用回溯，您也在搜索一棵可能巨大的树。

你是对的，回溯方法将是必要的，并且树/搜索空间很大。

回溯可能是一个好的开始。下一个更强大的方法可能是 SAT 求解器（需要进行丑陋的转换）和约束编程（更容易制定）。后者可以受益于强大的全局约束。

@sascha 你指的是什么丑陋的转变？

对于蛮力，你可以从Recursive backtracking in Java for solving a crossword复制代码（在cmets中有一个指向a presumably working complete program的链接）。

【参考方案1】：

您的基本想法非常明智：

识别板上的插槽。 用合适的词尝试每个槽。 如果每个槽都可以填满而不冲突，那就解决了。

这是一个绝妙的计划。 下一步是将其转化为设计。 对于像这样的小程序，我们可以直接进入伪代码。 正如其他答案所解释的那样，它的要点是recursion：

1  Draw a slot from the slot pool.
2     If slot pool is empty (all slots filled), stop solving.
3  For each word with correct length:
4     If part of the slot is filled, check conflict.
5        If the word does not fit, continue the loop to next word.
      // No conflict
6     Fill the slot with the word.
      // Try next slot (down a level)
7     Recur from step 1.
8     If the recur found no solution, revert (take the word back) and try next.
   // None of them works
9  If no words yield a solution, an upper level need to try another word.
   Revert (put the slot back) and go back.

以下是我根据您的要求编写的一个简短但完整的示例。

给猫剥皮的方法不止一种。 我的代码交换了第 1 步和第 2 步，并将第 4 步到第 6 步合并到一个填充循环中。

关键点：

使用格式化程序使代码适合您的风格。 二维板存储在row-major order 中的线性字符数组中。 这允许clone() 保存板并由arraycopy 恢复。 在创建时，会从两个方向对板进行两次扫描以查找插槽。 两个槽列表由同一个循环求解，主要区别在于槽的填充方式。 显示循环过程，以便您了解它的工作原理。 做了许多假设。没有单个字母槽，所有单词大小写相同，板正确等。 请耐心等待。学习新事物并给自己时间来吸收它。

来源：

import java.awt.Point;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class Crossword 

   public static void main ( String[] args ) 
      new Crossword( Arrays.asList( "5 4 4\n#_#_#\n_____\n#_##_\n#_##_\ntuna\nmusic\ncan\nhi".split( "\n" ) ) );
      new Crossword( Arrays.asList( "6 6 4\n##_###\n#____#\n___#__\n#_##_#\n#____#\n##_###\nnice\npain\npal\nid".split( "\n" ) ) );
   

   private final int height, width; // Board size
   private final char[] board; // Current board state.  _ is unfilled.  # is blocked.  other characters are filled.
   private final Set<String> words; // List of words
   private final Map<Point, Integer> vertical = new HashMap<>(), horizontal = new HashMap<>();  // Vertical and horizontal slots

   private String indent = ""; // For formatting log
   private void log ( String message, Object... args )  System.out.println( indent + String.format( message, args ) ); 

   private Crossword ( List<String> lines ) 
      // Parse input data
      final int[] sizes = Stream.of( lines.get(0).split( "\\s+" ) ).mapToInt( Integer::parseInt ).toArray();
      width = sizes[0];  height = sizes[1];
      board = String.join( "", lines.subList( 1, height+1 ) ).toCharArray();
      words = new HashSet<>( lines.subList( height+1, lines.size() ) );
      // Find horizontal slots then vertical slots
      for ( int y = 0, size ; y < height ; y++ )
         for ( int x = 0 ; x < width-1 ; x++ )
            if ( isSpace( x, y ) && isSpace( x+1, y ) ) 
               for ( size = 2 ; x+size < width && isSpace( x+size, y ) ; size++ ); // Find slot size
               horizontal.put( new Point( x, y ), size );
               x += size; // Skip past this horizontal slot
            
      for ( int x = 0, size ; x < width ; x++ )
         for ( int y = 0 ; y < height-1 ; y++ )
            if ( isSpace( x, y ) && isSpace( x, y+1 ) ) 
               for ( size = 2 ; y+size < height && isSpace( x, y+size ) ; size++ ); // Find slot size
               vertical.put( new Point( x, y ), size );
               y += size; // Skip past this vertical slot
            
      log( "A " + width + "x" + height + " board, " + vertical.size() + " vertical, " + horizontal.size() + " horizontal." );
      // Solve the crossword, horizontal first then vertical
      final boolean solved = solveHorizontal();
      // Show board, either fully filled or totally empty.
      for ( int i = 0 ; i < board.length ; i++ ) 
         if ( i % width == 0 ) System.out.println();
         System.out.print( board[i] );
      
      System.out.println( solved ? "\n" : "\nNo solution found\n" );
   

   // Helper functions to check or set board cell
   private char get ( int x, int y )  return board[ y * width + x ]; 
   private void set ( int x, int y, char character )  board[ y * width + x ] = character; 
   private boolean isSpace ( int x, int y )  return get( x, y ) == '_'; 

   // Fit all horizontal slots, when success move to solve vertical.
   private boolean solveHorizontal () 
      return solve( horizontal, this::fitHorizontal, "horizontally", this::solveVertical );
   
   // Fit all vertical slots, report success when done
   private boolean solveVertical () 
      return solve( vertical, this::fitVertical, "vertically", () -> true );
   

   // Recur each slot, try every word in a loop.  When all slots of this kind are filled successfully, run next stage.
   private boolean solve ( Map<Point, Integer> slot, BiFunction<Point, String, Boolean> fill, String dir, Supplier<Boolean> next ) 
      if ( slot.isEmpty() ) return next.get(); // If finished, move to next stage.
      final Point pos = slot.keySet().iterator().next();
      final int size = slot.remove( pos );
      final char[] state = board.clone();
      /* Try each word */                                                   indent += "  ";
      for ( String word : words ) 
         if ( word.length() != size ) continue;
         /* If the word fit, recur. If recur success, done! */              log( "Trying %s %s at %d,%d", word, dir, pos.x, pos.y );
         if ( fill.apply( pos, word ) && solve( slot, fill, dir, next ) )
            return true;
         /* Doesn't match. Restore board and try next word */               log( "%s failed %s at %d,%d", word, dir, pos.x, pos.y );
         System.arraycopy( state, 0, board, 0, board.length );
      
      /* No match.  Restore slot and report failure */                      indent = indent.substring( 0, indent.length() - 2 );
      slot.put( pos, size );
      return false;
   

   // Try fit a word to a slot.  Return false if there is a conflict.
   private boolean fitHorizontal ( Point pos, String word ) 
      final int x = pos.x, y = pos.y;
      for ( int i = 0 ; i < word.length() ; i++ ) 
         if ( ! isSpace( x+i, y ) && get( x+i, y ) != word.charAt( i ) ) return false; // Conflict
         set( x+i, y, word.charAt( i ) );
      
      return true;
   
   private boolean fitVertical ( Point pos, String word ) 
      final int x = pos.x, y = pos.y;
      for ( int i = 0 ; i < word.length() ; i++ ) 
         if ( ! isSpace( x, y+i ) && get( x, y+i ) != word.charAt( i ) ) return false; // Conflict
         set( x, y+i, word.charAt( i ) );
      
      return true;
   

练习：可以rewrite递归到迭代；速度更快，可以支持更大的电路板。 完成后，它可以转换为多线程并运行得更快。

【参考方案2】：

你是对的，问题是NP-complete。所以你最好的机会是通过蛮力解决它（如果你找到多项式算法请告诉我，我们都可以有钱=）。

我建议你看看 backtracking。它将允许您为填字游戏问题编写一个优雅（但考虑到您的输入大小但速度较慢）的解决方案。

如果您需要更多鼓舞人心的材料，请查看this solver，它使用回溯作为导航解决方案树的方法。

请注意，有些算法在实践中可能比纯蛮力执行得更好（尽管仍然具有指数复杂性）。 此外，在 scholar 上快速搜索会发现很多关于该主题的论文，您可能想看看，例如：

using genetic algorithm using a probabilistic approach

【讨论】：

“你说得对，问题是 NP 完全问题。所以你最好的机会是通过暴力破解”。这没有多大意义。旅行商问题是 NP 完全问题，但存在比蛮力好多 的算法（尽管它们仍然是指数级的）。

是的，我知道，我不想说暴力破解是解决问题的唯一方法。通过“你最好的机会”，我的意思是一个简单的回溯将是正确的并且非常容易实现（因为她正在寻求帮助，所以我认为这将是一个很好的起点）。我将更新答案以使其更清楚=）。不过很好，谢谢。

嗯，它们只是在带有额外假设的非一般环境中比蛮力更好。我不认为这句话是错误的（理论上）。

太好了，希望对您有所帮助。祝你编码好运

你能提供一些示例输入和输出吗？

【参考方案3】：

填字游戏是一个约束满足问题，通常是一个 NP-Complete，但是有许多求解器会将最有效的算法应用于您指定的约束问题。 Z3 SMT 求解器可以非常轻松地大规模解决这些问题。您所要做的就是编写一个 Java 程序，将填字游戏转换为求解器可以理解的 SMT 问题，然后将其交给求解器来求解。 Z3 有 Java 绑定，所以应该很简单。我已经编写了 Z3 代码来解决下面的第一个示例。遵循 Java 程序中的模式来指定任意大的十字路口谜题对您来说应该不难。

; Declare each possible word as string literals
(define-const str1 String "tuna")
(define-const str2 String "music")
(define-const str3 String "can")
(define-const str4 String "hi")

; Define a function that returns true if the given String is equal to one of the possible words defined above.
(define-fun validString ((s String)) Bool 
    (or (= s str1) (or (= s str2) (or (= s str3) (= s str4)))))

; Declare the strings that need to be solved
(declare-const unknownStr1 String)
(declare-const unknownStr2 String)
(declare-const unknownStr3 String)
(declare-const unknownStr4 String)

; Assert the correct lengths for each of the unknown strings.
(assert (= (str.len unknownStr1) 4))
(assert (= (str.len unknownStr2) 5))
(assert (= (str.len unknownStr3) 3))
(assert (= (str.len unknownStr4) 2))

; Assert each of the unknown strings is one of the possible words.
(assert (validString unknownStr1))
(assert (validString unknownStr2))
(assert (validString unknownStr3))
(assert (validString unknownStr4))

; Where one word in the crossword puzzle intersects another assert that the characters at the intersection point are equal.
(assert (= (str.at unknownStr1 1) (str.at unknownStr2 1)))
(assert (= (str.at unknownStr2 3) (str.at unknownStr4 1)))
(assert (= (str.at unknownStr2 4) (str.at unknownStr3 0)))

; Solve the model
(check-sat)
(get-model)

我推荐 Z3 SMT 求解器，但还有很多其他的约束求解器。您不需要实现自己的约束求解算法，就像您不需要实现自己的排序算法一样。

【参考方案4】：

为了使这个问题更容易解决，我将把它分解成更小、更容易的问题。请注意，我不包括代码/算法，因为我相信这在这里无济于事（如果我们想要最好的代码，就会有索引和数据库以及黑魔法，只要看到它就会让你的脑袋爆炸）。相反，这个答案试图通过讨论有助于 OP 使用最适合读者的方法解决这个问题（以及未来的问题）的思维方法来回答这个问题。

你需要知道的

此答案假设您知道如何执行以下操作

创建和使用具有属性和功能的对象 选择一个适用于（不一定是好的）您想要对其内容进行处理的数据结构。

为您的空间建模

因此，将您的填字游戏加载到 n x m 矩阵（二维数组，此处称为“网格”）中很容易，但实际使用起来非常容易。因此，让我们首先将您的填字游戏从网格解析为合法对象。

就您的程序需要知道的而言，填字游戏中的每个条目都有 4 个属性。

第一个字母在网格中的 X-Y 坐标 一个方向（向下或横向） 字长 字值 绑定索引的映射 关键字：与另一个条目共享的单词索引 值：与索引共享的条目 （您可以将其设为元组并包含来自其他条目的共享索引以便于引用）

您可以在扫描时根据这些规则在网格中找到它们。

如果 Row_1_up 关闭而 Row_1_down 打开，则这是向下字的起始索引。 （向下扫描长度。对于绑定索引，左侧或右侧空间将打开。向左扫描以获取链接条目coord-id） 与 1 相同，但跨词旋转（您可以在扫描 1 的同时执行此操作）

在您的填字游戏对象中，您可以使用坐标+方向作为键来存储条目，以便于参考和轻松转换为文本网格形式。

使用您的模型

您现在应该有一个包含填字游戏条目集合的对象，其中包含相关的索引绑定。您现在需要找到一组满足您所有条目的值。

你的入口对象应该有像isValidEntry(str)这样的辅助方法来检查给定的值和填字游戏的当前状态，我可以把这个词放在这里吗？通过使模型中的每个对象负责其自己的逻辑级别，一个思考层的问题的代码可以只调用逻辑而不用担心它的实现（在这个例子中，你的求解器不必担心逻辑of 是一个有效的值，它可以问isValidEntry）

如果您已完成上述正确操作，那么解决问题就很简单了，只需遍历所有条目的所有单词即可找到解决方案。

子问题列表

作为参考，这是我的子问题列表，你需要写一些东西来解决。

如何以理想的方式为我的工作空间建模，让我易于使用？ 对于我的模型的每一部分，它需要知道什么？它可以为我处理什么逻辑？ 如何将我的文本输入转换为可用的模型对象？ 如何使用模型对象解决我的问题？ （对你来说，它是迭代所有单词/所有条目以找到一个有效的集合。也许使用递归）

【参考方案5】：

我刚刚在 Scala 中实现了一个代码来解决这些难题。我只是使用递归来解决问题。简而言之，对于每个单词，我找到所有可能的槽，然后选择一个槽并用单词填充它，并尝试用递归解决部分难题。如果拼图不能用剩下的单词填满，它会尝试另一个槽，等等。如果没有，拼图就解决了。

这是我的代码的链接： https://github.com/mysilver/AMP/blob/master/Crossword.scala