生成填字游戏的算法

Question

给定一个单词列表，您将如何将它们排列成填字游戏网格？

它不必像对称的“正确”填字游戏或类似的东西：基本上只是输出每个单词的起始位置和方向。

Answer 1

虽然这是一个较旧的问题，但我会根据我所做的类似工作尝试回答。

解决约束问题的方法有很多（一般属于 NPC 复杂性类）。

这与组合优化和约束规划有关。 在这种情况下，约束是网格的几何形状和单词唯一的要求等。

随机化/退火方法也可以工作（尽管在适当的设置内）。

高效简约或许才是终极智慧！

要求是或多或少完整的填字游戏编译器和（可视化所见即所得）构建器。

抛开所见即所得构建器部分，编译器概要如下：

1. 加载可用的单词列表（按单词长度排序，即 2,3,..,20）

2. 在用户构建的网格上查找词槽（即网格词）（例如，位于 x,y 处的词，长度为 L，水平或垂直）（复杂度 O(N) ）< /p>

3. 计算网格词的交点（需要填充的）（复杂度 O(N^2) ）

4. 计算交集单词列表中单词的数量以及所使用的字母表中的各个字母（这允许使用模板搜索匹配的单词，例如Sik Cambon 论文所使用的通过 cwc ）（复杂度 O(WL*AL) ）

步骤 .3 和 .4 允许执行此任务：

A。 网格单词与其自身的交叉点能够创建一个“模板”，用于尝试在该网格单词的可用单词的相关单词列表中找到匹配项（通过使用与该单词相交的其他单词的字母，这些单词已经在某个位置填充）算法的步骤）

b． 单词列表中的单词与字母表的交集能够找到与给定“模板”匹配的匹配（候选）单词（例如，第一个位置的“A”和第三个位置的“B”等。）

因此，使用这些数据结构实现所使用的算法是这样的：

注意：如果网格和单词数据库是恒定的，则前面的步骤只需完成一次。

1. 算法的第一步是随机选择一个空词槽（网格词），并用关联词列表中的候选词填充它（随机化能够在算法的连续执行中产生不同的解决方案）（复杂度 O(1)或 O(N) )

2. 对于每个仍然为空的字槽（与已填充的字槽有交集），计算约束比（这可能会有所不同，简单的是可用解决方案的数量该步骤）并按此比率对空字槽进行排序（复杂度 O(NlogN) 或 O(N) ）

3. 循环遍历上一步计算的空字槽并为每个空字槽尝试一些候选解决方案（确保“弧一致性被保留”，即如果使用这个词，网格在这一步之后有一个解决方案）并根据下一步的最大可用性对它们进行排序（即下一步有最大可能）解决方案，如果该单词当时在该地点使用，等等..）（复杂度 O(N*MaxCandidatesUsed) ）

4. 填充该单词（将其标记为已填充并转到步骤 2）

5. 如果没有找到满足步骤 .3 的标准的单词，请尝试回溯到先前步骤的另一个候选解决方案（此处的标准可能有所不同）（复杂度 O(N) ）

6. 如果找到回溯，请使用替代方案，并可选择重置任何已填充的单词可能需要重置（再次将它们标记为未填充）（复杂度 O(N) ）

7. 如果没有找到回溯，则无法找到解决方案（至少使用此配置、初始种子等。）

8. 否则，当所有字块都被填满时，您有一个解决方案

该算法对问题的解决方案树进行随机一致游走。 如果在某个时刻出现死胡同，它会回溯到前一个节点并遵循另一条路线。 直到找到解决方案或各个节点的候选数量耗尽。

一致性部分确保找到的解决方案确实是一个解决方案，而随机部分能够在不同的执行中产生不同的解决方案，并且平均而言具有更好的性能。

附言。 所有这些（以及其他）都是在纯 JavaScript（具有并行处理和所见即所得）功能

PS2 中实现的。 该算法可以轻松并行化，以便同时产生多个（不同的）解决方案

希望这有帮助

Answer 2

为什么不直接使用随机概率方法呢？ 从一个单词开始，然后重复选择一个随机单词，并尝试将其适应拼图的当前状态，而不打破大小等限制。如果失败，就重新开始。

您会惊讶地发现，像这样的蒙特卡罗方法经常有效。

Answer 3

这是一些基于 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();
}

Answer 4

我会生成两个数字：长度和拼字游戏得分。 假设拼字游戏得分低意味着加入更容易（低分=大量常见字母）。 按长度降序和拼字游戏得分升序对列表进行排序。

接下来，只需沿着列表向下查看即可。 如果该单词不与现有单词交叉（分别根据每个单词的长度和拼字游戏分数检查），则将其放入队列中，并检查下一个单词。

冲洗并重复，这应该会生成一个填字游戏。

当然，我很确定这是 O(n!) 并且不能保证为您完成填字游戏，但也许有人可以改进它。

Answer 5

我一直在思考这个问题。 我的感觉是，要创建一个真正密集的填字游戏，你不能指望有限的单词列表就足够了。 因此，您可能需要将字典放入“trie”数据结构中。 这将使您可以轻松找到填补剩余空间的单词。 在 trie 中，实现遍历（例如给出“c?t”形式的所有单词）是相当有效的。

因此，我的总体想法是：创建某种相对强力的方法，如此处描述的一些方法来创建低密度交叉，并用字典单词填充空白。

如果其他人采取了这种方法，请告诉我。

Answer 6

我正在玩填字游戏生成器引擎，我发现这是最重要的：

0.!/usr/bin/python

1. a. allwords.sort（key=len，reverse=True）

   b. 制作一些像光标这样的项目/对象，它将围绕矩阵走动以便于定位
   除非您想稍后通过随机选择进行迭代。

2. 首先，拿起第一对并将它们放在 0,0 的横向和下方；
   将第一个存储为我们当前的填字游戏“领导者”。

3. 按顺序对角线或以更大对角线概率随机移动光标到下一个空单元格

   按

4. 迭代单词，如并使用可用空间长度定义最大字长：
   <代码>
   温度=[]
   对于范围内的 w_size( len( w_space ), 2, -1 ) ：
   # t
   for w in [ if len(word) == w_size ] 中的字对字：
   #
   如果 w 不在 temp 中并且 putTheWord( w, w_space ) ：
   #
   临时.追加（w）

5. 将单词与我使用的可用空间进行比较 ie ：

   w_space=['c','.','a','.','.','.'] # 而点是空白单元格 
   
     # 转换多个“.”   正则表达式的“.*” 
   
     模式 = r''.join( [ x.letter for x in w_space ] ) 
     模式=pattern.strip('.') +'.*' 如果模式[-1] == '.'   其他模式 
   
     prog = re.compile( 模式, re.U | re.I ) 
   
     如果 prog.match( w ) ： 
         # 
         如果 prog.match( w ).group() == w ： 
             # 
             返回真 
     

6. 在每个成功使用的单词后，改变方向。
   当所有单元格都被填充时循环，或者你用完单词或者通过迭代限制然后：

# CHANGE ALL WORDS LIST
inexOf1stWord = allwords.index(leading_w )
allwords = allwords[:inexOf1stWord+1][:] + allwords[inexOf1stWord+1:][:]

...并再次迭代新的填字游戏。

7. 通过填写的难易程度和一些估计计算来制定评分系统。
   为当前填字游戏给出分数，并通过将其附加到来缩小以后的选择范围
   如果您的评分系统满足分数，则制作填字游戏列表。

8. 在第一次迭代会话之后，再次从制作的填字游戏列表中迭代以完成工作。

   在第一次迭代

通过使用更多参数，速度可以大大提高。

Answer 7

该项目作为哈佛大学AI CS50 课程中的一个项目出现。 这个想法是将填字游戏生成问题表述为约束满足问题，并通过不同启发式的回溯来解决它，以减少搜索空间。

首先，我们需要几个输入文件：

1. 填字游戏的结构（如下所示，例如，其中“#”代表不填充的字符，“_”代表要填充的字符） )

`

###_####_#
____####_#
_##_#_____
_##_#_##_#
______####
#_###_####
#_##______
#_###_##_#
_____###_#
#_######_#
##_______#    

`

2. 输入词汇（单词列表/词典），从中选择候选单词（如下所示）。

   <代码>一个
   放弃
   能力
   有能力的
   流产
   关于
   多于
   国外
   缺席
   绝对
   绝对地
   ...

现在，CSP 的定义和求解如下：

1. 变量被定义为具有来自作为输入提供的单词（词汇表）列表中的值（即它们的域）。
2. 每个变量都由一个 3 元组表示：（网格坐标、方向、长度），其中坐标表示相应单词的开头，方向可以是水平或垂直，长度定义为变量将要出现的单词的长度分配给。
3. 约束由提供的结构输入定义：例如，如果水平和垂直变量具有公共字符，则它将表示为重叠（弧）约束。
4. 现在可以使用节点一致性和AC3弧一致性算法来减少域。
5. 然后回溯以获得具有 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█

`

以下动画显示了回溯步骤：

这是另一张包含孟加拉语（孟加拉语）语言单词列表的图片：

< a href="https://i.sstatic.net/RveHK.gif" rel="nofollow noreferrer">

Answer 8

我会得到每个单词所使用的每个字母的索引，以了解可能的交叉。 然后我会选择最大的单词并将其用作基础。 选择下一个大的并划掉它。 冲洗并重复。 这可能是一个NP问题。

另一个想法是创建一种遗传算法，其中强度度量是您可以在网格中放入多少单词。

我发现最困难的部分是何时知道某个列表不可能被跨越。

Answer 9

我已经为这个问题编写了一个 JavaScript/jQuery 解决方案：

示例演示：http://www.earthfluence.com/crossword-puzzle-demo.html

源代码：https://github.com/HoldOffHunger/jquery-crossword-puzzle-generator

我使用的算法的目的：

1. 最小化网格中不可用方块的数量，如下所示尽可能多。
2. 尽可能多地混合单词。
3. 计算速度极快。

我将描述我使用的算法：

1. 根据具有共同字母的单词将单词分组在一起。

2. 从这些组中，构建新数据结构（“单词块”）的集合，该结构是一个主要单词（贯穿所有其他单词），然后是其他单词（贯穿主要单词）。

3. 开始填字游戏时，第一个单词块位于填字游戏的左上角。

   开始填字

4. 对于其余的单词块，从填字游戏最右下角的位置开始，向上和向左移动，直到没有更多可用的空位来填充。 如果向上的空列多于向左的空列，则向上移动，反之亦然。

Answer 10

我想出了一个可能不是最有效的解决方案，但它效果很好。 基本上：

1. 按长度降序对所有单词进行排序。
2. 取出第一个单词并将其放在黑板上。
3. 接下一个词。
4. 搜索黑板上已有的所有单词，看看是否与该单词有任何可能的交叉点（任何常见字母）。
5. 如果该单词存在可能的位置，则循环遍历板上的所有单词并检查新单词是否干扰。
6. 如果这个词没有破坏木板，则将其放置在那里并转到步骤 3，否则，继续寻找位置（步骤 4）。
7. 继续这个循环，直到所有单词都被放置或无法放置。

这是一个可行但通常很糟糕的填字游戏。 我对上面的基本配方做了一些修改，以获得更好的结果。

• 生成填字游戏结束后，根据放置的单词数量（越多越好）、板子有多大（越小越好）以及高宽比（越接近）给它一个分数为 1 更好）。 生成多个填字游戏，然后比较它们的分数并选择最好的一个。
  • 我决定在任意时间内创建尽可能多的填字游戏，而不是运行任意数量的迭代。 如果您只有一个小单词列表，那么您将在 5 秒内获得数十个可能的填字游戏。 较大的填字游戏可能只能从 5-6 种可能性中选择。
• 当放置一个新单词时，不要在找到可接受的位置后立即放置它，而是根据它增加网格大小的程度以及有多少交叉点给该单词位置打分（理想情况下，您希望每个单词都是被 2-3 个其他单词交叉）。 跟踪所有位置及其分数，然后选择最好的一个。

Answer 11

我最近刚刚用 Python 编写了自己的代码。 您可以在这里找到它： http://bryanhelmig.com/python-crossword-puzzle-generator/ 。 它不会创建密集的《纽约时报》风格的填字游戏，而是创建您可能在儿童拼图书中找到的填字游戏风格。

与我在那里发现的一些算法不同，这些算法实现了像一些人建议的那样放置单词的随机蛮力方法，我尝试在单词放置时实现一种稍微聪明的蛮力方法。 这是我的过程：

1. 创建一个任意大小的网格和一个单词列表。
2. 打乱单词列表，然后按最长到最短的顺序对单词进行排序。
3. 将第一个也是最长的单词放在最左上角的位置 1,1（垂直或水平）。
4. 移至下一个单词，循环遍历单词中的每个字母和网格中的每个单元格，查找字母与字母的匹配。
5. 找到匹配项后，只需将该位置添加到该单词的建议坐标列表中即可。
6. 循环显示建议的坐标列表，并根据单词交叉的其他单词数量对单词位置进行“评分”。 0 分表示位置不佳（与现有单词相邻）或没有单词交叉。
7. 返回步骤#4，直到单词列表用完。 可选的第二遍。
8. 我们现在应该有一个填字游戏，但由于一些随机放置，质量可能会受到影响。 因此，我们缓冲这个填字游戏并返回到步骤 #2。 如果下一个填字游戏有更多的单词放置在板上，它将替换缓冲区中的填字游戏。 这是有时间限制的（在 x 秒内找到最佳填字游戏）。

到最后，你就会得到一个不错的纵横字谜或单词搜索谜题，因为它们大致相同。 它往往运行得相当好，但如果您有任何改进建议，请告诉我。 更大的网格运行速度呈指数级下降； 更大的单词列表呈线性。 更大的单词列表也更有可能获得更好的单词位置数。

Answer 12

实际上，我大约十年前编写了一个填字游戏生成程序（它很神秘，但相同的规则适用于普通的填字游戏）。

它有一个单词列表（以及相关的线索）存储在一个文件中，按迄今为止的使用情况降序排序（以便较少使用的单词位于文件的顶部）。 一个模板，基本上是一个代表黑色和自由方块的位掩码，是从客户提供的池中随机选择的。

然后，对于拼图中的每个不完整的单词（基本上找到第一个空白方块，看看右边的（跨词）或下面的（下词）是否也是空白），进行搜索文件寻找第一个合适的单词，同时考虑该单词中已有的字母。 如果没有合适的单词，您只需将整个单词标记为不完整并继续。

最后是一些未完成的单词，编译器必须填写这些单词（如果需要，可以将单词和线索添加到文件中）。 如果他们无法提出任何想法，他们可以手动编辑填字游戏以更改约束或只是要求完全重新生成。

一旦单词/线索文件达到一定大小（并且每天为该客户添加 50-100 条线索），很少有需要对每个填字游戏进行超过两到三个手动修复的情况。

Answer 13

此算法创建 50 个密集的 6x9 箭头填字游戏 在 60 秒内完成。 它使用单词数据库（带有单词+提示）和板数据库（带有预配置的板）。

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)