生成填字游戏的算法
Answers:
我想出了一个可能不是最有效的解决方案，但是效果很好。基本上：
- 按长度排序所有单词，降序排列。
- 选择第一个单词并将其放在板上。
- 下一个词。
- 搜索板上已经存在的所有单词，查看该单词是否存在任何可能的交集（任何常见字母）。
- 如果该单词可能存在，请遍历黑板上所有单词并检查是否有新单词干扰。
- 如果该单词没有破坏木板，则将其放在那儿，然后转到步骤3，否则，继续寻找位置（步骤4）。
- 继续此循环，直到所有单词都被放置或无法放置。
这使一个工作正常但通常很差的填字游戏。我对上面的基本配方进行了许多更改，以得出更好的结果。
- 在生成填字游戏的最后，根据放置的单词数（越多越好），木板的大小（越小越好）以及高度和宽度之间的比例（越近）为其打分。到1更好）。生成多个填字游戏，然后比较它们的得分并选择最佳的一个。
- 我决定不运行任意数量的迭代，而是决定在任意时间内创建尽可能多的填字游戏。如果您只有一个很小的单词列表，那么您将在5秒钟内得到数十个可能的填字游戏。较大的填字游戏只能从5-6种可能性中选择。
- 当放置一个新单词时，与其在找到可接受的位置后立即放置它，不如根据它增加网格大小和相交的数量给该单词位置打分（理想情况下，您希望每个单词都是越过2-3个其他字词）。跟踪所有位置及其得分，然后选择最佳位置。
我最近才用Python编写了自己的代码。您可以在这里找到它：http : //bryanhelmig.com/python-crossword-puzzle-generator/。它不会创建密集的NYT风格填字游戏，但是会在儿童的益智书中找到填字游戏的样式。
与我发现的一些算法不同，这些算法实现了随机的蛮力放置单词的方法，就像一些人建议的那样，我尝试在单词放置时实现一种稍微更聪明的蛮力方法。这是我的过程：
- 创建一个任意大小的网格和单词列表。
- 随机排列单词列表，然后按最长到最短的顺序对单词进行排序。
- 将第一个单词和最长单词放在最左上角的位置1,1（垂直或水平）。
- 移至下一个单词，在单词中的每个字母和网格中的每个单元格上循环，以查找字母对字母的匹配项。
- 找到匹配项后，只需将该位置添加到该单词的建议坐标列表中即可。
- 循环浏览建议的坐标列表，并根据其通过的其他单词数“得分”。分数为0表示位置不正确（与现有单词相邻）或没有单词交叉。
- 返回步骤4，直到单词列表用尽为止。可选的第二遍。
- 现在，我们应该有一个填字游戏，但是由于某些随机放置，质量可能会受到打击或错过。因此，我们缓冲此填字游戏，然后返回到步骤2。如果下一个填字游戏在板上有更多的单词，它将替换缓冲区中的填字游戏。这是受时间限制的（以x秒为单位查找最佳填字游戏）。
最后，您将获得一个不错的填字游戏或单词搜索游戏，因为它们大致相同。它通常运行得很好，但是如果您有任何改进建议，请告诉我。更大的网格以指数级的速度运行；较大的单词线性排列。更大的单词列表也有更高的机会获得更好的单词放置数。
array.sort(key=f)是稳定的，这意味着（例如）简单地按长度对字母单词列表进行排序将使所有8个字母的单词保持字母排序。
实际上，大约十年前我写了一个填字游戏生成程序（虽然很神秘，但是相同的规则适用于普通填字游戏）。
它具有存储在文件中的单词（及相关线索）列表，该列表按迄今为止的用法降序排列（因此，较少使用的单词位于文件的顶部）。从客户端提供的池中随机选择了一个模板，基本上是一个代表黑色和自由正方形的位掩码。
然后，对于拼图中的每个未完成单词（基本上找到第一个空白方块，然后查看右侧的一个（交叉单词）或下方的一个（向下单词）是否也是空白），进行了搜索该文件将查找第一个合适的单词，并考虑该单词中已有的字母。如果没有合适的单词，您只需将整个单词标记为不完整，然后继续。
最后将是一些未完成的单词，编译器将不得不填写这些单词（如果需要，可以在文件中添加单词和线索）。如果他们无法提出任何想法，则可以手动编辑填字游戏以更改约束条件，或者仅要求完全重新生成。
一旦单词/线索文件达到一定大小（每天为该客户增加50-100条线索），很少会为每个填字游戏进行两次或三个以上的手动修正。
此算法可在60秒内创建50个密集的6x9 箭头填字游戏。它使用一个单词数据库（带有单词+提示）和一个木板数据库（带有预先配置的木板）。
1) Search for all starting cells (the ones with an arrow), store their size and directions
2) Loop through all starting cells
2.1) Search a word
2.1.1) Check if it was not already used
2.1.2) Check if it fits
2.2) Add the word to the board
3) Check if all cells were filled
更大的单词数据库会大大减少生成时间，并且某些板子更难填充！更大的木板需要更多时间才能正确填充！
例：
预先配置的6x9电路板：
（＃表示一个单元格中的一个技巧，％表示一个单元格中的两个技巧，箭头未显示）
# - # # - % # - #
- - - - - - - - -
# - - - - - # - -
% - - # - # - - -
% - - - - - % - -
- - - - - - - - -
生成的6x9开发板：
# C # # P % # O #
S A T E L L I T E
# N I N E S # T A
% A B # A # G A S
% D E N S E % W E
C A T H E D R A L
提示[行，列]：
[1,0] SATELLITE: Used for weather forecast
[5,0] CATHEDRAL: The principal church of a city
[0,1] CANADA: Country on USA's northern border
[0,4] PLEASE: A polite way to ask things
[0,7] OTTAWA: Canada's capital
[1,2] TIBET: Dalai Lama's region
[1,8] EASEL: A tripod used to put a painting
[2,1] NINES: Dressed up to (?)
[4,1] DENSE: Thick; impenetrable
[3,6] GAS: Type of fuel
[1,5] LS: Lori Singer, american actress
[2,7] TA: Teaching assistant (abbr.)
[3,1] AB: A blood type
[4,3] NH: New Hampshire (abbr.)
[4,5] ED: (?) Harris, american actor
[4,7] WE: The first person of plural (Grammar)
尽管这是一个较旧的问题，但将根据我所做的类似工作尝试给出答案。
解决约束问题的方法有很多（总的来说属于NPC复杂性类别）。
这与组合优化和约束编程有关。在这种情况下，约束条件是网格的几何形状以及单词唯一性的要求等。
随机/退火方法也可以使用（尽管在适当的设置下）。
高效的简单性可能只是终极智慧！
要求是针对一个或多或少完整的填字游戏编译器和（可视WYSIWYG）构建器。
除了所见即所得的生成器部分，编译器的轮廓是这样的：
加载可用的单词表（按单词长度排序，即2,3，..，20）
在用户构造的网格上找到单词槽（即网格单词）（例如，x，y处的字符，水平或垂直长度为L）（复杂度O（N））
计算网格词的交点（需要填充）（复杂度O（N ^ 2））
计算单词表中的单词与所用字母的各种字母的交集（这允许使用模板（例如，cwc使用的Sik Cambon论文）来搜索匹配的单词）（复杂度O（WL * AL））
步骤.3和.4允许执行此任务：
一个。网格词本身的交集能够创建一个“模板”，以尝试在该网格词的可用词的关联词列表中查找匹配项（通过使用已与此词相交的其他相交词的字母来填充）算法的步骤）
b。单词表中的单词与字母的交集使得能够找到与给定的“模板”匹配的匹配（候选）单词（例如，“ A”排在第一位，“ B”排在第三位等）。
因此，在实现了这些数据结构后，所使用的算法如下：
注意：如果单词的网格和数据库是恒定的，则前面的步骤只能执行一次。
该算法的第一步是随机选择一个空单词槽（网格词），并从其关联的单词表中填充一个候选单词（随机化使得算法连续执行时可以产生不同的解决方案）（复杂度O（1）或O（ N））
对于每个仍然为空的单词槽（与已经填充的单词槽有交集），计算约束比率（此比率可以变化，很简单，这是该步骤可用的解决方案的数量），然后按该比率对空的单词槽进行排序（复杂度O（NlogN ）或O（N））
循环遍历在上一步中计算出的空单词槽，并针对每个候选单词尝试许多候选解决方案（确保“保留弧一致性”，即，如果使用了该单词，则网格在此步骤之后有一个解决方案），并根据下一步的最大可用性（即，如果当时在那个地方使用了这个词，那么下一步具有最大可能的解决方案，等等。）（复杂度O（N * MaxCandidatesUsed））
填写该单词（将其标记为已填充，然后转到步骤2）
如果没有找到满足步骤.3的条件的单词，则尝试回溯到某个先前步骤的另一个候选解决方案（条件在此处可能有所不同）（复杂度O（N））
如果找到回溯，请使用替代方法并有选择地重设可能需要重设的所有已填充词（再次将其标记为未填充）（复杂度O（N））
如果未找到回溯，则无法找到解决方案（至少使用此配置，初始种子等。）
否则，当所有字槽都填满时，您只有一个解决方案
该算法对问题的解决方案树进行随机一致的遍历。如果在某个时候出现死角，它将回溯到上一个节点并遵循另一条路线。直到找到解决方案或各种节点的候选数量都用完为止。
一致性部分可确保找到的解决方案确实是解决方案，而随机部分可确保在不同的执行中生成不同的解决方案，并且平均而言具有更好的性能。
PS。所有这些（以及其他）都是在纯JavaScript中实现的（具有并行处理和所见即所得）功能
PS2。可以轻松并行化该算法，以便同时生成多个（不同）解决方案
希望这可以帮助
为什么不只是使用随机概率方法开始呢？从一个单词开始，然后反复选择一个随机单词，并尝试使其适应拼图的当前状态，而不会破坏大小等方面的限制。如果失败，则重新开始。
您会惊讶于这样的蒙特卡洛方法的工作频率。
这是一些基于nickf的答案和Bryan的Python代码的JavaScript代码。只是发布它，以防别人在js中需要它。
function board(cols, rows) { //instantiator object for making gameboards
this.cols = cols;
this.rows = rows;
var activeWordList = []; //keeps array of words actually placed in board
var acrossCount = 0;
var downCount = 0;
var grid = new Array(cols); //create 2 dimensional array for letter grid
for (var i = 0; i < rows; i++) {
grid[i] = new Array(rows);
}
for (var x = 0; x < cols; x++) {
for (var y = 0; y < rows; y++) {
grid[x][y] = {};
grid[x][y].targetChar = EMPTYCHAR; //target character, hidden
grid[x][y].indexDisplay = ''; //used to display index number of word start
grid[x][y].value = '-'; //actual current letter shown on board
}
}
function suggestCoords(word) { //search for potential cross placement locations
var c = '';
coordCount = [];
coordCount = 0;
for (i = 0; i < word.length; i++) { //cycle through each character of the word
for (x = 0; x < GRID_HEIGHT; x++) {
for (y = 0; y < GRID_WIDTH; y++) {
c = word[i];
if (grid[x][y].targetChar == c) { //check for letter match in cell
if (x - i + 1> 0 && x - i + word.length-1 < GRID_HEIGHT) { //would fit vertically?
coordList[coordCount] = {};
coordList[coordCount].x = x - i;
coordList[coordCount].y = y;
coordList[coordCount].score = 0;
coordList[coordCount].vertical = true;
coordCount++;
}
if (y - i + 1 > 0 && y - i + word.length-1 < GRID_WIDTH) { //would fit horizontally?
coordList[coordCount] = {};
coordList[coordCount].x = x;
coordList[coordCount].y = y - i;
coordList[coordCount].score = 0;
coordList[coordCount].vertical = false;
coordCount++;
}
}
}
}
}
}
function checkFitScore(word, x, y, vertical) {
var fitScore = 1; //default is 1, 2+ has crosses, 0 is invalid due to collision
if (vertical) { //vertical checking
for (i = 0; i < word.length; i++) {
if (i == 0 && x > 0) { //check for empty space preceeding first character of word if not on edge
if (grid[x - 1][y].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
} else if (i == word.length && x < GRID_HEIGHT) { //check for empty space after last character of word if not on edge
if (grid[x+i+1][y].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
if (x + i < GRID_HEIGHT) {
if (grid[x + i][y].targetChar == word[i]) { //letter match - aka cross point
fitScore += 1;
} else if (grid[x + i][y].targetChar != EMPTYCHAR) { //letter doesn't match and it isn't empty so there is a collision
fitScore = 0;
break;
} else { //verify that there aren't letters on either side of placement if it isn't a crosspoint
if (y < GRID_WIDTH - 1) { //check right side if it isn't on the edge
if (grid[x + i][y + 1].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
if (y > 0) { //check left side if it isn't on the edge
if (grid[x + i][y - 1].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
}
}
}
} else { //horizontal checking
for (i = 0; i < word.length; i++) {
if (i == 0 && y > 0) { //check for empty space preceeding first character of word if not on edge
if (grid[x][y-1].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
} else if (i == word.length - 1 && y + i < GRID_WIDTH -1) { //check for empty space after last character of word if not on edge
if (grid[x][y + i + 1].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
if (y + i < GRID_WIDTH) {
if (grid[x][y + i].targetChar == word[i]) { //letter match - aka cross point
fitScore += 1;
} else if (grid[x][y + i].targetChar != EMPTYCHAR) { //letter doesn't match and it isn't empty so there is a collision
fitScore = 0;
break;
} else { //verify that there aren't letters on either side of placement if it isn't a crosspoint
if (x < GRID_HEIGHT) { //check top side if it isn't on the edge
if (grid[x + 1][y + i].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
if (x > 0) { //check bottom side if it isn't on the edge
if (grid[x - 1][y + i].targetChar != EMPTYCHAR) { //adjacent letter collision
fitScore = 0;
break;
}
}
}
}
}
}
return fitScore;
}
function placeWord(word, clue, x, y, vertical) { //places a new active word on the board
var wordPlaced = false;
if (vertical) {
if (word.length + x < GRID_HEIGHT) {
for (i = 0; i < word.length; i++) {
grid[x + i][y].targetChar = word[i];
}
wordPlaced = true;
}
} else {
if (word.length + y < GRID_WIDTH) {
for (i = 0; i < word.length; i++) {
grid[x][y + i].targetChar = word[i];
}
wordPlaced = true;
}
}
if (wordPlaced) {
var currentIndex = activeWordList.length;
activeWordList[currentIndex] = {};
activeWordList[currentIndex].word = word;
activeWordList[currentIndex].clue = clue;
activeWordList[currentIndex].x = x;
activeWordList[currentIndex].y = y;
activeWordList[currentIndex].vertical = vertical;
if (activeWordList[currentIndex].vertical) {
downCount++;
activeWordList[currentIndex].number = downCount;
} else {
acrossCount++;
activeWordList[currentIndex].number = acrossCount;
}
}
}
function isActiveWord(word) {
if (activeWordList.length > 0) {
for (var w = 0; w < activeWordList.length; w++) {
if (word == activeWordList[w].word) {
//console.log(word + ' in activeWordList');
return true;
}
}
}
return false;
}
this.displayGrid = function displayGrid() {
var rowStr = "";
for (var x = 0; x < cols; x++) {
for (var y = 0; y < rows; y++) {
rowStr += "<td>" + grid[x][y].targetChar + "</td>";
}
$('#tempTable').append("<tr>" + rowStr + "</tr>");
rowStr = "";
}
console.log('across ' + acrossCount);
console.log('down ' + downCount);
}
//for each word in the source array we test where it can fit on the board and then test those locations for validity against other already placed words
this.generateBoard = function generateBoard(seed = 0) {
var bestScoreIndex = 0;
var top = 0;
var fitScore = 0;
var startTime;
//manually place the longest word horizontally at 0,0, try others if the generated board is too weak
placeWord(wordArray[seed].word, wordArray[seed].displayWord, wordArray[seed].clue, 0, 0, false);
//attempt to fill the rest of the board
for (var iy = 0; iy < FIT_ATTEMPTS; iy++) { //usually 2 times is enough for max fill potential
for (var ix = 1; ix < wordArray.length; ix++) {
if (!isActiveWord(wordArray[ix].word)) { //only add if not already in the active word list
topScore = 0;
bestScoreIndex = 0;
suggestCoords(wordArray[ix].word); //fills coordList and coordCount
coordList = shuffleArray(coordList); //adds some randomization
if (coordList[0]) {
for (c = 0; c < coordList.length; c++) { //get the best fit score from the list of possible valid coordinates
fitScore = checkFitScore(wordArray[ix].word, coordList[c].x, coordList[c].y, coordList[c].vertical);
if (fitScore > topScore) {
topScore = fitScore;
bestScoreIndex = c;
}
}
}
if (topScore > 1) { //only place a word if it has a fitscore of 2 or higher
placeWord(wordArray[ix].word, wordArray[ix].clue, coordList[bestScoreIndex].x, coordList[bestScoreIndex].y, coordList[bestScoreIndex].vertical);
}
}
}
}
if(activeWordList.length < wordArray.length/2) { //regenerate board if if less than half the words were placed
seed++;
generateBoard(seed);
}
}
}
function seedBoard() {
gameboard = new board(GRID_WIDTH, GRID_HEIGHT);
gameboard.generateBoard();
gameboard.displayGrid();
}
我在玩填字游戏生成器引擎，发现这是最重要的：
0。!/usr/bin/python
一个。
allwords.sort(key=len, reverse=True)b。制作一些像光标一样的项目/对象，它将绕着矩阵走动以便于定向，除非您以后想要通过随机选择进行迭代。
第一个，拿起第一对，并将它们从0,0向下放置；将第一个存储为当前的填字游戏“ leader”。
将光标按对角线顺序或以较大对角线概率随机移动到下一个空单元格
遍历like之类的单词，并使用自由空间长度定义最大单词长度：
temp=[] for w_size in range( len( w_space ), 2, -1 ) : # t for w in [ word for word in allwords if len(word) == w_size ] : # if w not in temp and putTheWord( w, w_space ) : # temp.append( w )比较单词和我使用的自由空间，即：
w_space=['c','.','a','.','.','.'] # whereas dots are blank cells # CONVERT MULTIPLE '.' INTO '.*' FOR REGEX pattern = r''.join( [ x.letter for x in w_space ] ) pattern = pattern.strip('.') +'.*' if pattern[-1] == '.' else pattern prog = re.compile( pattern, re.U | re.I ) if prog.match( w ) : # if prog.match( w ).group() == w : # return True在每个成功使用的单词之后，更改方向。在所有单元格都已填充的同时循环，或者您用完了所有单词，或者通过迭代限制，然后：
# CHANGE ALL WORDS LIST
inexOf1stWord = allwords.index( leading_w )
allwords = allwords[:inexOf1stWord+1][:] + allwords[inexOf1stWord+1:][:]
...并再次迭代新的填字游戏。
通过填充的难易程度和一些估算来建立评分系统。如果您的计分系统满意，给当前填字游戏打分，并通过将其添加到已填字谜列表中来缩小以后的选择范围。
在第一次迭代会话之后，再次从生成的填字游戏列表中进行迭代以完成工作。
通过使用更多参数，可以极大地提高速度。
我已经为这个问题编写了JavaScript / jQuery解决方案：
示例演示：http : //www.earthfluent.com/crossword-puzzle-demo.html
源代码：https : //github.com/HoldOffHunger/jquery-crossword-puzzle-generator
我使用的算法的目的是：
- 尽可能减少网格中无法使用的正方形的数量。
- 尽可能多地混合单词。
- 计算速度非常快。
我将描述我使用的算法：
根据共享共同字母的单词将单词分组在一起。
从这些组中，构建新数据结构（“单词块”）的集合，该数据结构是一个主要单词（贯穿所有其他单词），然后是其他单词（贯穿主要单词）。
首先在纵横字谜的左上角位置中的第一个单词块开始纵横字谜。
对于其余的字块，从填字游戏的最右下位置开始，向上和向左移动，直到没有更多可用的插槽可填充。如果向上的空列多于向左的空列，则向上移动，反之亦然。
var crosswords = generateCrosswordBlockSources(puzzlewords);。只需控制台记录此值。别忘了，游戏中有一个“作弊模式”，您只需单击“显示答案”即可立即获得该值。
这是哈佛AI CS50课程中的一个项目。想法是将填字游戏生成问题公式化为约束满足问题，并通过使用不同的启发式方法回溯来解决它，以减少搜索空间。
首先，我们需要几个输入文件：
- 填字游戏的结构（如下图所示，例如，“＃”代表不填充的字符，“ _”代表待填充的字符）
`
###_####_#
____####_#
_##_#_____
_##_#_##_#
______####
#_###_####
#_##______
#_###_##_#
_____###_#
#_######_#
##_______#
`
一种输入词汇表（单词列表/词典），从中可以选择候选单词（如下所示）。
a abandon ability able abortion about above abroad absence absolute absolutely ...
现在，CSP的定义和解决方法如下：
- 变量被定义为具有作为输入提供的单词（词汇）列表中的值（即，它们的域）。
- 每个变量都由3个元组表示：（grid_coordinate，方向，长度），其中坐标表示相应单词的开头，方向可以是水平或垂直，长度定义为该变量将要单词的长度分配给。
- 约束由提供的结构输入定义：例如，如果水平和垂直变量具有相同的字符，则将其表示为重叠（弧）约束。
- 现在，可以使用节点一致性和AC3弧一致性算法来缩小域。
- 然后回溯以获取具有MRV（最小剩余值），度等的CSP解决方案（如果存在）。试探法可用于选择下一个未分配的变量，试探法如LCV（最小约束值）可用于域-排序，以使搜索算法更快。
下面显示了使用CSP解决算法的实现获得的输出：
`
███S████D█
MUCH████E█
E██A█AGENT
S██R█N██Y█
SUPPLY████
█N███O████
█I██INSIDE
█Q███E██A█
SUGAR███N█
█E██████C█
██OFFENSE█
`
以下动画显示了回溯步骤：
这是另一个带有孟加拉（孟加拉）语言单词列表的单词：
