2小时上手约束求解：用MiniZinc自动解《纽约时报》Pips拼图

不知道你们有没有玩过《纽约时报》的那个叫 Pips 的每日拼图？游戏地址是 https://www.nytimes.com/games/pips 。

规则很简单，就是把一套多米诺骨牌放到一个特定形状的网格里，然后满足一堆条件。比如下面这个“简单”难度的题目，紫色的格子加起来要等于8，红色格子里的点数要小于5，三个绿色格子里的点数要完全相等。

说实话，这种级别的题，动动脑子还行。但一旦到了“中等”或者“困难”难度，我就开始想偷懒了。我的第一反应是：这玩意儿能不能写个程序自动解？

巧了，那几天正好看到一篇文章，标题挺唬人的——《很多Hard难度的LeetCode题，其实就是个简单的约束问题》。文章里介绍了一个叫 约束求解器 的东西，它的思路很有意思：你不用告诉计算机“怎么”去解，你只需要告诉它“要什么”，也就是列出所有必须满足的条件，它就能自己“变”出答案来。

这不正是给Pips量身定做的吗？

但我也嘀咕：这东西会不会数学门槛特别高？表达问题会不会很麻烦？求解起来会不会是天文数字级的穷举，跑一天都没结果？

结果，真香了。

从我对约束求解一无所知，到成功跑出第一个Pips的答案，总共花了不到两个小时。大部分题目，求解器几十毫秒就搞定了。今天，我就以一个纯小白的视角，跟大家聊聊我用 MiniZinc（一个约束建模工具）搞定Pips拼图的过程，代码和思路都会贴出来，咱们一起看看这种“声明式编程”到底有多爽。

第一步：告诉电脑我想要什么

在常规编程里，你写 for 循环，写递归回溯，一步一步教电脑怎么走。但在MiniZinc里，你只需要定义好变量，然后写下条件。

比如，针对上面那个“简单”题目，我可以直接把那三个要求翻译成代码，完全是直译：

% 紫色格子（坐标[1,1]和[2,1]）加起来等于8
constraint pips[1,1] + pips[2,1] == 8;
% 红色格子（坐标[2,3]）点数小于5
constraint pips[2,3] < 5;
% 三个绿色格子（坐标[3,1], [3,2], [3,3]）点数全部相等
constraint all_equal([pips[3,1], pips[3,2], pips[3,3]]);

是不是感觉在看一个超详细的题目说明书？

当然，光有题目条件不够，还得告诉电脑这个网格长啥样，以及我们手里有哪些多米诺骨牌。这也很简单，用数组就能搞定：

% 定义网格形状：1表示有格子，0表示没有
grid = [|
1,1,0|
1,1,1|
1,1,1|];

% 定义手里的四张牌（每张牌左右两半的点数）
spots = [|5,1| 1,4| 4,2| 1,3|];

第二步：让电脑理解“多米诺”是什么

接下来是最核心的一步：我得让电脑明白，这些牌是怎么“放”到格子上去的。这需要一点建模的巧思。

我没有去定义每张牌是横着放还是竖着放，那样要考虑的方向太多了。我的思路很简单：把每张牌的“两半”看成独立的个体，分别指定它们的坐标（x, y）。然后，我只需要加一个约束，保证这两半是挨着的就行。

% 每张牌的两半，要么x坐标差1（竖着放），要么y坐标差1（横着放）
constraint forall(i in DOMINO) (abs(x[i, 1] - x[i, 2]) + abs(y[i, 1] - y[i, 2]) == 1);

有了坐标，我就能把牌上的点数填到网格的对应位置了。这也是一个约束：

% 将每张牌的两半放到网格的对应坐标上
constraint forall(i in DOMINO, j in HALF) (pips[y[i,j], x[i, j]] == spots[i, j]);

为了让最后的结果看起来更清晰，也为了防止两张牌重叠，我还创建了一个叫 dominogrid 的数组，记录每个格子上放的是第几张牌：

% 记录每个格子被哪张牌占据
constraint forall(i in DOMINO, j in HALF) (dominogrid[y[i,j], x[i, j]] == i);

最后，再确保牌只放在允许放置的格子上（不能在网格形状的“窟窿”里）：

% 如果dominogrid的某个格子不是0（放了牌），那么对应的grid必须允许放牌（grid不为0）
constraint forall(i in 1..H, j in 1..W) (dominogrid[i, j] == 0 \/ grid[i, j] != 0);

说实话，当时我建完这些数组和约束，心里挺没底的。变量之间互相引用，约束一层套一层，我特别担心求解器会在这里绕晕，陷入无穷无尽的逻辑循环里，最后给我抛一句“无解”。但事实是，它真的就找到了答案。

见证奇迹的时刻：出结果了

点下运行按钮，心跳还没加速，结果就出来了：

耗时：55毫秒。

pips 数组就是答案格子里的点数，dominogrid 则告诉你每个格子属于哪张牌（1号、2号、3号或4号）。为了方便看，我还用MiniZinc的JavaScript API简单画了个图：

虽然只是个简单题，但那一刻，看着电脑自己“想”出来的答案，还是觉得有点神奇。

踩坑与惊喜：没有一帆风顺的编程

当然，过程也不是一直这么顺。我总结了几点教训：

1. 求解器太“聪明”了，反而给我添乱。有一次我想让它找出所有可能的解，结果它给我生成了成千上万种。仔细一看才发现，那些没有被任何牌占据的空白格子，它居然也给随机赋了值。虽然这些解满足了所有我写的条件，但它们本质上毫无意义。这就是约束求解器的特点：你写什么条件，它就严格遵守什么条件。如果你没说“空白格子必须为零”，它就觉得那里放什么都行。 所以，写约束时一定要把话说死。
2. 报错只有一句话：“无解”。当你把题目条件写错，比如数组索引搞反了，求解器不会告诉你是哪错了，只会冷冰冰地告诉你“unsatisfiable”。这该怎么调试？我的笨办法是，先把所有自定义的约束删掉，然后一条一条加回去，看加上哪一条之后问题变得不可解，那么问题就出在那条上。
3. 求解器也看心情：有时几十毫秒，有时几小时。这可能是最让我困惑的一点。同样一道“困难”难度的Pips题，我用MiniZinc默认的 Gecode 求解器，跑了几分钟都没动静。但是，当我在IDE里把后端求解器换成另一个叫 Chuffed 的，答案瞬间就出来了，而且还找到了 384种不同解法。

所以，如果一个求解器跑不出来，不妨换个试试。这就像找不同性格的侦探来破案，思路不一样，效率也不一样。

完整代码示例

我们只要改下骰子、网格的数字和相关的约束条件就能计算出相应的组合。下面就是完整的建模代码：

include "globals.mzn";

% 问题基本参数
int: NDOMINO = 4;
int: W = 3;
int: H = 3;

set of int: DOMINO = 1..NDOMINO;
set of int: HALF = 1..2;
set of int: XCOORD = 1..W;
set of int: YCOORD = 1..H;

% 决策变量
array[DOMINO, HALF] of var XCOORD: x;
array[DOMINO, HALF] of var YCOORD: y;
array[1..H, 1..W] of var 0..6: pips;
array[1..H, 1..W] of var 0..NDOMINO: dominogrid;

% 网格形状
array[1..H, 1..W] of 0..1: grid = [|
1,1,0|
1,1,1|
1,1,1|];

% 手里的牌
array[DOMINO, HALF] of int: spots = [|
5,1|
1,4|
4,2|
1,3|];

% 约束条件
constraint pips[1,1] + pips[2,1] == 8;
constraint pips[2,3] < 5;
constraint all_equal([pips[3,1], pips[3,2], pips[3,3]]);

constraint forall(i in DOMINO) (
abs(x[i,1] - x[i,2]) + abs(y[i,1] - y[i,2]) == 1
);

constraint forall(i in DOMINO, j in HALF) (
    pips[ y[i,j], x[i,j] ] == spots[i, j]
);

constraint forall(i in DOMINO, j in HALF) (
    dominogrid[ y[i,j], x[i,j] ] == i
);

constraint forall(i in 1..H, j in 1..W) (
    dominogrid[i, j] == 0 \/ grid[i, j] != 0
);

constraint forall(i in 1..H, j in 1..W) (
    grid[i, j] == 0 -> pips[i, j] == 0
);

% JSON 格式输出（便于 JavaScript 解析）
output [
    "{",
    "\"pips\": " ++ show(pips) ++ ", ",
    "\"domino\": " ++ show(dominogrid)
++ "}"
];

挑战困难难度：Pips February 20, 2026 求解

掌握了基本方法后，就可以挑战更难的题目了。比如下面这个2026年2月20日的困难题目：

题目网格和点数分布是这样的（0代表无格子）：

3, 3, 0, 0, 1, 1
0, 4, 0, 5, 5, 0
0, 4, 2, 2, 0, 0
3, 4, 0, 0, 6, 0
0, 4, 0, 6, 6, 0
0, 4, 4, 6, 0, 0

相应的约束条件也需要调整。经过建模和求解（这次我用的是Chuffed求解器），很快就得到了一个答案，并可视化了结果：

整个过程，电脑再次替我完成了最烧脑的部分。看着弹窗里的“Congrats!”，感觉比我自己解出来还有成就感。

它到底是怎么“想”的？

虽然我们不需要懂内部原理，但了解一下会很有意思。简单来说，你可以把求解过程想象成在一棵巨大的树里寻宝。第一个格子你可以放这张牌，也可以放那张牌，这就是树枝分叉。

传统的程序会一条路走到黑，直到碰壁才回头。但约束求解器会玩“心眼”：

• 聪明的顺序：它不会随便选个地方开始，而是优先尝试那些约束最强的格子，希望能尽快触发矛盾，从而一次性砍掉一整棵大树枝，大大缩小搜索范围。
• 提前预警：它还会做“约束传播”。比如，你设置了 A=B 和 B=C，当你尝试让 A=1 和 B=2 时，它不会傻等着最后去处理C，而是立刻推算出 A必须等于B ，所以这个赋值一开始就是错的。这种提前的矛盾检测，能避免大量的无效探索。

所有这些算法和优化，都藏在求解器的内核里，我们使用者完全不需要操心。这也是我喜欢它的原因之一：它能让你站在更高的抽象层次去思考问题。

写在最后

从一个突发奇想，到成功跑出代码，不过两小时。这次经历让我觉得，约束求解器并不是什么高深的数学工具，而是一种非常有趣的“编程思维拓展”。当你习惯了用“声明”而非“命令”的方式去解决问题时，很多以前觉得很复杂的逻辑题，都会变得通透起来。

当然，对我来说，写代码让电脑替我解Pips，本身就比我自己动手解要有意思得多。毕竟，这就是程序员的乐趣所在嘛！

如果你也想试试，可以去 https://www.minizinc.org/ 下载，读完半篇官方教程 https://docs.minizinc.dev/en/stable/part_2_tutorial.html 就能上手。这种从实际问题出发学习新工具的思路，也推荐你在 云栈社区 这样的技术论坛上和更多开发者交流，常常能碰撞出意想不到的火花。

---