引言

背包问题是动态规划中的经典问题，也是 GESP 六级必考的知识点。其原理虽然需要花一些时间，但大多数孩子都能掌握，但是到了具体的题目时，因为背包问题变化较多，就不那么容易写出代码来。

本文将试图把背包问题的各种考法都列举出来，帮助大家巩固练习。

背包问题

背包问题之所以叫这个名字，是因为其背景故事是：往一个容量有限的背包里面，放入一些物品。每个物品有不同的体积大小，所以会占用相应的背包的容量。物品不能被分割，所以要么整个放入背包中，要么不放入。我们需要找出放入背包的价值最大的方案。

举一个简单的例子，背包容量是 10L：

• 物品 1：体积 7 L，价值 8
• 物品 2：体积 5 L，价值 5
• 物品 3：体积 4 L，价值 4

虽然物品 1 的价值最大，价值/体积(即单位体积的价值)也最大，但是因为放入物品 1 之后，剩余的空间 3L 无法再放入别的物品而浪费掉了。就不如不放物品 1，而放入物品 2 和物品 3 带来的总价值大。

由此我们也能看出，背包问题不能用简单的贪心来解决，而需要用动态规划。

解题思路

背包问题的转移方程可以被优化为一维，但为了方便理解，我们先看没有优化的版本。我们定义：

• 每个元素的体积为 a[i]，价值为 v[i]。
• dp[i][j] 表示用前 i 个物品，放入容量为 j 的背包时，所能达到的最大价值

那对于第 i 个物品，如果我们已经知道了前面的结果，那么我们有两种选择：

• 不放入 第 i 个物品，这样 dp[i][j] = dp[i-1][j]
• 放入 第 i 个物品，这样 dp[i][j] = dp[i-1][j-a[i]] + v[i]

而以上就是状态转移方程，我们在上面两种情况下取最优的情况：dp[i][j] = max(dp[i-1][j], dp[i-1][j-a[i]] + v[i]) 。

另外我们需要考虑一下初始化的情况，即 dp[0][1~n] 应该怎么赋值。因为前 0 个物品什么都没选，那么价值肯定都是 0，所以让它们都等于 0 即可。

将以上逻辑写成代码如下：

1
2
3
4
5
6
7

memset(dp, 0, sizeof dp);
for (int i = 1; i <= 3; ++i)
    for (int j = 1; j <= 10; ++j) {
        dp[i][j] = dp[i-1][j];
        if (j-a[i]>=0)
            dp[i][j] = max(dp[i][j], dp[i-1][j-a[i]] + v[i]);
    }

在这段代码中，为了保证 j-a[i] 的值为正，加了一个 if 来检查，保证没有下标越界的代码。如果下标越界，有可能会读取到随机值，也可能读取到非法地址，造成运行异常（Runtime Error）。

我们再用刚刚的例子来做一下表格演示：背包容量是 10L。

• 物品 1：体积 7 L，价值 8
• 物品 2：体积 5 L，价值 5
• 物品 3：体积 4 L，价值 4

经过转移方程的计算，最终，我们可以填出下面这个二维表格，表格中的每一项都计算出来了用前 i 个物品，体积为 j 时的最优化方案。这也是符合动态规划的最优子结构的特征。

01 背包

所谓的 01 背包，就是指物品的数量只有 1 个，只有选与不选两种方案。刚刚的例子就是一个 01 背包的例子。

我们发现 dp[i][j] 只与两个值相关 dp[i-1][j] 和 dp[i-1][j-a[i]]，这样的二维数组利用的效率很低。所以，我们就想到，能不能把第 i 维省略掉，这样可以节省存储空间（但没有节省运算时间）。

压缩后的代码如下：

1
2
3
4
5

memset(dp, 0, sizeof dp);
for (int i = 1; i <= 3; ++i)
    for (int j = 10; j >= a[i]; --j) {
        dp[j] = max(dp[j], dp[j-a[i]] + v[i]);
    }

我们注意到，j 的循环方式从正序变成了逆序。之所以要这么操作，读者可以用表格的方式，把正着循环的结果填一下就能明白。

如果 j 不是倒着循环，在一轮 j 的循环过程中，dp[j] 的值会在修改后，再一次被访问到，这样就会使得一个物品实际上已经计算了放入的价值，又被重复计算第二次。

完全背包

一个物品被多次重复放入和重复计算价值，其实是我们在完全背包问题中需要的效果。所以，刚刚的代码，如果我们把 j 正序循环，就是完全背包的代码，如下所示：

1
2
3
4
5

memset(dp, 0, sizeof dp);
for (int i = 1; i <= 3; ++i)
    for (int j = a[i]; j <= 10; ++j) {
        dp[j] = max(dp[j], dp[j-a[i]] + v[i]);
    }

但是为了方便理解，我们还是把完全背包的非压维代码也一并看一下：

1
2
3
4
5
6
7
8
9

memset(dp, 0, sizeof dp);
for (int i = 1; i <= 3; ++i)
    for (int j = 1; j <= 10; ++j) {
        dp[i][j] = dp[i-1][j];
        if (j-a[i]>=0) {
            dp[i][j] = max(dp[i][j], dp[i-1][j-a[i]] + v[i]);
            dp[i][j] = max(dp[i][j], dp[i][j-a[i]] + v[i]);
        }
    }

因为 dp[i][j-a[i]] >= dp[i-1][j-a[i]]，所以以上代码可以省略成：

1
2
3
4
5
6
7
8

memset(dp, 0, sizeof dp);
for (int i = 1; i <= 3; ++i)
    for (int j = 1; j <= 10; ++j) {
        dp[i][j] = dp[i-1][j];
        if (j-a[i]>=0) {
            dp[i][j] = max(dp[i][j], dp[i][j-a[i]] + v[i]);
        }
    }

我们可以记住这个写法，因为后面有一些题因为各种情况可能无法压维，就会需要这种写法。

我们还是用刚刚的例子来填写二维表格，背包容量是 10L。物品数量改为无限。

• 物品 1：体积 7 L，价值 8
• 物品 2：体积 5 L，价值 5
• 物品 3：体积 4 L，价值 4

以下是填写出来的值：

题目变为完全背包后，可以看到最后答案变了，最优方案变成了放入两个物品 2，得到最大价值 10。

学习完以上内容后，可以让学生练习以下两道题：

多重背包

多重背包描述了这样一种场景，一个物品将同时受两个限制条件的制约，例如：一个背包，即有体积限制，又有重量限制，让你往里放物品，求最大化物品价值的放法。

P1794 装备运输 就是多重背包的一道典型例题，在题目中，每件武器有体积和重量两个限制条件。

对于多重背包，我们同样用前 i 个物品来划分阶段：

• dp[i][j] 表示 i 体积 j 重量下的最大火力。
• 转移方程：dp[i][j] = max(dp[i][j], dp[i-v[k]][j-g[k]] + t[k]);

同理，如果物品的数量是无限的，则正着 for，如果物品的数量是有限的，则倒着 for。

P1794 装备运输 的参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <bits/stdc++.h>
using namespace std;

int V, G, N, dp[510][510], v[510], g[510], t[510];

int main() {
    cin >> V >> G >> N;
    for (int i = 1; i <= N; ++i)
        cin >> t[i] >> v[i] >> g[i];
    for (int k = 1; k <= N; ++k)
        for (int i = V; i>= v[k]; i--)
            for (int j = G; j >= g[k]; j--)
                dp[i][j] = max(dp[i][j], dp[i-v[k]][j-g[k]] + t[k]);
    cout << dp[V][G];
    return 0;
}

如果把 01 背包和完全背包想像成填一个一维的表格，那么多重背包就在填一个二维的表格。我们需要保证表格的填写过程符合动态规划的阶段性，表格总是从一个方向往另一个方向填，填过的数字不会再次被修改（在没压维的情况下），这样才能保证状态无后效性。

动态规划题目能够划分出清晰的阶段，后一个阶段只依赖于前面的阶段，问题就解决了一大部分。

背包变型一：物品的相互依赖

P1064 金明的预算方案 描述了一种背包问题的变型：在此题中，物品不是简单的 1 个或多个，而是分为主件或附件，每个主件可以有 0 个、1 个或 2 个附件。

应该如何表示这种复杂的物品关系呢？其实，我们可以把物品的每种组合都枚举出来，因为附件数量最多为 2 个，所以情况就可以枚举出以下情况：

• 不选主件（当然也就没有附件）
• 选主件，不选附件
• 选主件+附件 1
• 选主件+附件 2
• 选主件+附件 1+附件 2

于是，我们就可以在处理主件的时候，把以上几种情况都比较一下，选最优的方案。

参考代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int m;
    int w;
    int t;
};

int n, m;
vector<Node> va;
vector<vector<Node> > vb;
int dp[40000];

void updateDP(int i, int m, int w) {
    if (i-m >= 0) {
        dp[i] = max(dp[i], dp[i-m] + w);
    }
}

int main() {
    scanf("%d%d", &n, &m);
    va.resize(m);
    vb.resize(m);
    for (int i = 0; i < m; ++i) {
        Node node;
        scanf("%d%d%d", &node.m, &node.w, &node.t);
        node.w = node.w*node.m; 
        va[i] = node;
        if (node.t != 0) {
            vb[node.t - 1].push_back(node);
        }
    }
    memset(dp, 0, sizeof(dp));
    for (int i = 0; i < m; ++i) {
        // 只处理主件，附件与主体一并处理
        if (va[i].t == 0) {
            for (int j = n; j > 0; j--) {
                // 选主件，不选附件
                updateDP(j, va[i].m,va[i].w);
                // 选主件+附件 1
                if (vb[i].size() > 0) {
                    int money = va[i].m + vb[i][0].m;
                    int weight = va[i].w + vb[i][0].w;
                    updateDP(j, money, weight);
                }
                // 选主件+附件 2
                if (vb[i].size() == 2) {
                    int money = va[i].m + vb[i][1].m;
                    int weight = va[i].w + vb[i][1].w;
                    updateDP(j , money, weight);
                }
                // 选主件+附件 1+附件 2
                if (vb[i].size() == 2) {
                    int money = va[i].m + vb[i][0].m + vb[i][1].m;
                    int weight = va[i].w + vb[i][0].w + vb[i][1].w;
                    updateDP(j, money, weight);
                }
            }   
        }
    }
    cout << dp[n] << endl;
    return 0;
}

背包变型二：求最小值

有些时候，我们不是求背包能够装的物品的最大价值，而是求最小价值。例如 B3873 小杨买饮料 这题，此题我们可以把饮料的容量当作背包的容量，把饮料的价格当作价值，但是此题相对于标准的背包问题有两个变化：

• 1、题目希望求最小的费用，相当于背包所装的物品价值需要最低。
• 2、题目给定的背包容量不固定，而是“不低于 L”。

针对以上的变化，我们的状态定义虽然不变，用 dp[i][j] 表示前 i 种饮料在 j 容量下的最小价值，但是状态转移变成了：
dp[i][j] = min(dp[i-1][j-l[i]] + c[i], dp[i-1][j])

在这种情况下，初始的第 0 种饮料什么都喝的值为 0，即：dp[0][0] = 0。

但是其它的值就不能设置成 0 了，如果设置成 0，那么任何情况下 dp[i][j]就已经是最小的值了，就不能被更新了。我们需要把 dp[i][j]默认的值设置成“无穷大”，这样才可能更新出有意义的值。

在设置无穷大这件事情上，有一个使用 memset 的技巧，即：memset(dp, 0x7f, sizeof dp);，此技巧将每个字节都填充成了二进制的 01111111（即 0x7f），因为最高为是符号位，所以保留成 0。这种 memset 技巧虽然初始化的值比 INT_MAX 略小一点，但是写起来更快，另外在进行加法运算的时候，也不用担心结果溢出成负数。

以上方案解决了变化一。我们再来看变化二。

变化二使得答案不一定在 dp[i][L]，因为答案不一定是刚好 L 升，所以要取 L ~ L+max(l[i]) 这一段范围。这样就解决了变化二。

最后我们用滚动数组压维，然后因为是 01 背包（每个饮料只能选一次），我们压维之后需要倒着 for 循环背包大小。

以下是参考代码，代码中用 STL 的 min_element 来求最小值，读者也可以参考这种写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * 01 背包问题的变化
 * 
 * 假设第 i 种饮料的费用是 c[i], 容量是 l[i]
 * dp[i][j] 表示用前 i 种饮料，凑成 j 升的最小费用。
 * 
 * 则，转移方程为：
 *  - dp[i][j] = min( dp[i-1][j-l[i]] + c[i] , dp[i-1][j] ) 
 * 
 * 因为 i 只与 i-1 相关，所以这一层可以压缩。转移方式优化为：
 *  - dp[j] = min(dp[j- l[i]] + c[i], dp[j])
 * 
 * 初使化：
 *  - dp[0] = 0;
 *  - dp[1-L] = memset(0x7f)
 * 
 * 其它：
 *  - 倒着 dp，因为每种饮料只能用一次
 *  - 最大值检查了一下，不会超 int，就不用 long long 了
 *  - 因为答案不一定是刚好 L 升，所以要取 L ~ L+max(l[i]) 这一段范围
 *  - 因为是取最小值，所以初使化设置成 0x7f7f7f7f（接近 21 亿，但是又没到 INT_MAX），
 *    这样运算不会超 int，又可以是较大值
 * 
 * Author: Tang Qiao
 */
#include <bits/stdc++.h>
using namespace std;

int dp[1010000], c[550], l[550], N, L, maxL;

int main() {
    ios::sync_with_stdio(0);       
    cin >> N >> L;
    for (int i = 0; i < N; ++i) {
        cin >> c[i] >> l[i];
        maxL = max(maxL, l[i]);
    }
    maxL += L;
    memset(dp, 0x7f, sizeof dp);
    dp[0] = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = maxL; j - l[i] >= 0; --j) {
            dp[j] = min(dp[j], dp[j - l[i]] + c[i]);
        }
    }
    // 因为答案不一定是刚好 L 升，所以要取 L ~ L+max(l[i]) 这一段范围
    int ans = *min_element(dp+L, dp+maxL+1);
    if (ans == 0x7f7f7f7f) cout << "no solution" << endl;
    else cout << ans << endl;

    return 0;
}

以上代码虽然解决了问题，但是还有一点不完美，就是 dp 数组实在太大了。有没有可能 dp 数组更小呢？我们可以想到，因为每种饮料的价格都是正数，所以，如果有一个答案是超过 2*L 升的情况，同时它的价格极低，这种情况下，我们的答案就是只喝这一种饮料。不会出现超过 2*L 升，我们还叠加喝了两种饮料的情况。

我们可以反证：假如有一个答案是喝两种饮料，总容量超过 2*L 升，那么必定有一个饮料的容量是大于等于 L 升的。那么，我们只喝那个大于等于 L 升的饮料，肯定总价格更低。

所以，我们的优化方案就是：我们只需要把 dp 数组的大小开到 2*L 即 4000 即可（题目规定 L 最大为 2000）。在此优化方案下，我们再特判一下每个大于 L 升的饮料，看是不是更便宜。

以下是参考代码，时间和空间复杂度都更优：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <bits/stdc++.h>
using namespace std;

int dp[4100], c[550], l[550], N, L;

int main() {
    ios::sync_with_stdio(0);       
    cin >> N >> L;
    for (int i = 0; i < N; ++i) {
        cin >> c[i] >> l[i];
    }
    memset(dp, 0x7f, sizeof dp);
    dp[0] = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = 4000; j - l[i] >= 0; --j) {
            dp[j] = min(dp[j], dp[j - l[i]] + c[i]);
        }
    }
    int ans = *min_element(dp+L, dp+4000);
    // 如果单个饮料就可以超 L，则判断一下
    for (int i = 0; i < N; ++i)
        if (l[i] >= L) 
            ans = min(ans, c[i]);

    if (ans == 0x7f7f7f7f) cout << "no solution" << endl;
    else cout << ans << endl;

    return 0;
}

相关练习题目

推荐练习：

最近一段时间和 AI 聊游戏设计比较多。我主要用的是 google 首页上的 AI 模式，也试过 twitter 上的 grok 。

去年也和朋友聊过很多，但对理清楚自己的想法帮助有限。因为和人聊容易陷入不断的细节解释当中，一些天马行空的想法更容易被质疑，一旦陷入辩论就不太容易跳出来。而且每个人的时间并不固定，很容易造成时间和精力的浪费。和 AI 聊要轻松得多，AI 毕竟见多识广，随便提到的点都能接得上话。不想聊下去尽可以中断，不用担心浪费时间。即使怀疑 AI 出现幻觉，也可以随时暂停下来通过搜索核实。

不过，我觉得和 AI 讨论也有另一方面的问题。那就是太容易顺着你的思路夸大其词。它更像是一个貌似领域知识渊博但只是想讨好你的同好，不断的放出一些华丽的辞藻却在逻辑上经不起推敲。分析起游戏来头头是道，直到谈到我真的玩过上百小时的游戏时，对游戏的细节错误百出。如果我没有这些游戏的真实体验，几乎不可能分辨真伪。一开始我还会想和真人讨论时一样指出它的错误，让它修正后重新发表观点。后来就渐渐放弃了从 AI 那里直接获得真知。把它当成一个比搜索引擎更方便的信息获取入口就够了。

但我依然偶尔被 AI 的总结惊艳到。比如说有一场主题为模拟类型游戏的话题，聊到最后 AI 总结：

成功的模拟游戏本质上是“熵增模拟器”。设计师的任务是制造一个不断趋向于“热寂”和“混乱”的世界（交通拥堵、热量堆积、资源耗尽、情感崩溃），而玩家的乐趣在于投入自己的脑力作为“负熵”，去建立一个脆弱但精密的秩序。

所以，在设计时，不要害怕设计“笨拙”的规则（如巡逻员、有体积的货车、会变质的食物）。这些“物理摩擦力”正是通往成就感的阶梯。如果没有这些混乱，游戏就只是一张算好了答案的报表。

要让玩家感到“战胜了混乱”而不是“被垃圾规则恶心”，需要遵循以下原则：确定性的混乱：混乱的原因必须是可回溯的。 提供“高级工具”来解决“基础问题”：游戏初期给玩家简单的工具去面对混乱，中后期给玩家更高级的逻辑工具。从“点”到“面”的连锁反应：混乱不应是孤立的错误，而应该是系统性的连锁反应。

我觉得在这种形而上的话题上，它讲得还是蛮有道理的。但我依然不觉得这些总结真的可以成为游戏设计的指导工具。

当然，让 AI 说什么依然极度依赖你对它说了什么。大多数时候 AI 会信誓旦旦的帮忙做一些具体设计（当我想设计卡牌驱动的游戏时），可我真的实体化这些卡片试玩后，完全玩不下去。我实在没信心再和它讨论这些卡片设计上的具体细节：真的不如我自己从零设计高效。但有时候，AI 也会对设计游戏这件事情有所畏缩，一旦强调我应该先用卡纸或在桌面模拟器中自己尝试做个原型试试。总之，让我感觉本质上它还是在跟着我的情绪走。完全没有独立思考的痕迹。

意识到这点，我现在更想把今天的 AI 当成一种更高级的知识搜索引擎。从这个角度看，这段时间 AI 的确给我推荐了不少不错的游戏。虽然我仔细玩过之后，这些游戏给我的体验并非完全符合 AI 的描述，我还是感谢 AI 让我挖掘出了它们。

尤其值得一提的是 AI 极力向我推荐的 dotAGE 这个游戏。我一口气玩了接近 160 小时。

其实它刚上 steam 的时候我就玩过 demo ，当时只是觉得还不错，但没有深入。前几天 AI 反复督促我要仔细玩一下，我才沉浸了进去。这是款回合制没有战斗的城市建设游戏。随机元素很少，几乎所有要面对的灾难，都在游戏规则下提前预示给玩家。玩家要做的就是提前规划每个回合的行动，通过精算赢得游戏。值得一提的是，游戏推荐的难度和最高难度给我的几乎是截然不同的游戏体验。在默认难度下，即使对游戏规则不甚了解，不需要精确规划，也能通过运气赢得游戏胜利。那种“Push Your Luck”机制驱动带来的胜利是一种相当刺激的游戏体验；但在最高难度下，游戏变得无法通过运气获胜，转而必须精密规划。而这种精算带来的又是另一种成就感。

在玩游戏之余，我又阅读了作者在游戏发售前夕于 reddit 上写的两篇文章，方才了解到这个游戏几乎是作者一人在攻读完游戏设计专业的博士学位后，独自花了 9 年时间制作出来的，颇为震撼。怪不得我在玩的时候感觉这个游戏要深度有深度要广度有广度，完全不像是能短期做出来的。只能说，设计出好的游戏真的很难。

TODO

一如既往，主要在工具链领域耕耘。但由于工作忙碌在opensource社区投入的时间减少了。

Blogging

不包括这篇总结，一共写了18篇文章。

• Understandingand improving Clang -ftime-report
• Natural loops
• lld 20 ELFchanges
• Migratingcomments to giscus
• CompilingC++ with the Clang API
• Relocationgeneration in assemblers
• LLVMintegrated assembler: Improving MCExpr and MCValue
• LLVMintegrated assembler: Improving expressions and relocations
• GCC 13.3.0miscompiles LLVM
• LLVMintegrated assembler: Engineering better fragments
• LLVMintegrated assembler: Improving sections and symbols
• Understandingalignment - from source to object file
• Benchmarkingcompression programs
• lld 21 ELFchanges
• Remarks onSFrame
• Stackwalking: space and time trade-offs
• Sacramento游记
• Weak AVL Tree

llvm-project

• 翻新了integrated assembler，写了4篇相关的blog posts: https://maskray.me/blog/tags/assembler/

• Reviewednumerous patches. queryis:pr created:>2025-01-01 reviewed-by:MaskRay => "989Closed"

Linux kernel

贡献了两个commits，被引用了一次。

ccls

• clang.prependArgs
• 支持了LLVM 21和22

ELF specification

尝试推进compactsection header table，没有取得共识。 一些成员希望采用generalcompression (likezstd)的方式，像SHF_COMPRESSED那样压缩section headertable。包括我在内的另一些人不喜欢采用general compression。

Misc

Reported 6 feature requests or bugs to binutils.

• ld --build-id does not use symtab/strtab content
• gas: monolithic .sframe violates COMDAT group rule
• gas: Clarify whitespace between a label's symbol and its colon
• ld: Add --print-gc-sections=file
• ld riscv: Relocatable linking challenge with R_RISCV_ALIGN
• ld: add --why-live

旅行

• 第一次去：台南、西安、兰州、天水、Sacramento、Puerto Vallarta,Jalisco, Mexico、Mazatlán, Sinaloa, Mexico
• 曾经去过：台北(上一次是近11年前)、北京

tvOS 绝非 iPad 的放大版。本文是 Syncnext 播放器的工程实录，深入解析 Apple TV 开发的真实陷阱：从 Focus 焦点机制、严苛的存储限制，到 SwiftUI 填坑与 AVPlayer 深度调优，助开发者在 tvOS 平台上“活下来”

这几天一口气刷完了 Netflix 出品的《黑白厨师》，感触颇深。没想到 Cooking 也能套上《鱿鱼游戏》的外壳：极简的规则，极端的赌注，有限的时间，封闭系统内的零和博弈。

在看之前，我对「温馨的烹饪」能否与「大逃杀美学」兼容是非常存疑的。但看完后不得不佩服，Netflix 不仅处理得很好，还在这场残酷的阶级叙事中，端出了一盘关于「人性」与「身份」的顶级料理。

机制：绝对真空里的「强制公平」

如果把《黑白厨师》看作一部韩剧，「机制」就是它最精彩的剧本。烹饪综艺最大的痛点在于：味觉是主观的，如何保证结果的公正与说服力？

节目组做了一个极其大胆的设定——蒙眼试吃。

当白钟元和安成宰蒙上眼睛，张嘴等待喂食时，这画面不仅充满了某种荒诞的宗教仪式感，更是一种暴力的强制公平。它强行抹去了「白汤匙」积累数十年的名声红利，把米其林三星主厨和外卖店老板拉到了同一条起跑线（味蕾）上。这种「在一个不公平的世界里创造一个残酷但公平的真空」，正是大逃杀题材最迷人的地方。

而评委的「双璧」设定，则是机制中另一个神来之笔。白钟元代表着「大众的味蕾」与「商业的敏锐」，追求直觉的爽感；安成宰则代表「精英的标准」与「技术的严苛」，追求意图的精准。两人的争论，实际上是将「好吃究竟有没有标准」这一哲学命题具象化了。这种价值观的碰撞，也是一大看点。

场景：感官的高压工厂

Netflix 的综艺有一种你一看就知道是「Netflix 出品」的质感。巨大的仓库、整齐划一的 40 个烹饪台、冰冷的不锈钢，当 40 名黑汤匙同时开火，那个画面不像厨房，更像是一个高压工厂或战场。为了满足 4K/HDR 的严苛画质，灯光采用了电影级的布光，甚至连声音设计都做到了极致——备菜的切剁声、炉火的轰鸣声，营造出一种 ASMR 般的沉浸感（一种让人头皮发麻、脊背发凉但又感到极度舒适和放松的生理反应）。这种极致的物理压迫感，会把屏幕前的观众也拉进去（所以一定要看高清的）。

玩家：艺术家与谋略家

如果说机制如剧本，厨师就是演员。除了对「厨艺」和「哲学」的考核，这档节目更深层地展现了「生存博弈」。

这就不得不提崔铉硕主厨。如果说其他人是在比赛做菜，那么崔铉硕更像是在「玩游戏」。在团队海鲜战中，他疯狂囤积扇贝让对手无材可用；在餐厅经营战中，他制定超高价策略，以极少的出餐量换取了最高的营业额。他敏锐地捕捉到了现代餐饮的残酷真相：厨艺好不等于会经营，商业头脑往往决定生死。

他的存在，打破了传统厨师的刻板印象，为节目注入了《鱿鱼游戏》的智斗感。

当然，这也是一个群像极佳的舞台。制作组显然精心挑选了那些拥有「鲜活、粗糙且充满生命力故事」的人。如果没有这些故事，这就是一场单纯的技艺展示；有了这些故事，菜品就有了灵魂。

核心人物：诗意与狂傲

最终的决战也是我心目中最好的结局，两位风格迥异的厨师，分别代表了烹饪的两个极端。

Edward Lee：寻找归途的诗人

看到 Edward Lee 的第一眼，就感觉到一种不一样的气质：说话不疾不徐，有一种淡淡的诗意。即使年过半百，依然像个少年一样在寻求突破。

对于他而言，这不仅仅是比赛，更是一场「身份认同的寻根之旅」。作为一个在美国长大的韩裔，他的料理（如拌饭口味的冰淇淋）本身就在挑战「正统韩餐」的定义。决赛那道「辣炒年糕点心」是整季的高光时刻。当他用不熟练的韩文念出那封信，讲述「Edward 喜欢威士忌，但李均（他的韩文名）喝玛格丽」时，那种异乡人的孤独与对故土的深情，瞬间把我击穿。

那不勒斯美味黑手党（权圣晙）：专注的狂徒

如果 Edward 是水，权圣晙就是火。他身上体现的是年轻人的自信、狂傲，以及极致的专注。

在败者复活赛中，当所有人都在做咸口菜时，他独辟蹊径选择做甜品「栗子提拉米苏」。为了防止食材被拿走，他守在冷柜前啃巧克力的画面，有一种「认真的拙劲」。他选择 Edward Lee 战队时的果断，以及决赛前的放狠话环节，都展现了他极强的策略性和胜负欲：

“爱德华主厨，为了让你早点回家休息，今天我会速战速决。”

这种狂傲并不让人讨厌，因为他有与之匹配的实力。

我有时也会切换视角：假如自己是 Netflix 的决策者，面对这样一个项目，如何确保「基本能回本」（保底能力），同时又可能挣很多（其实就是价值投资）？对于白汤匙、黑汤匙、白钟元、安成宰，他们决定参与的动机是什么？杠杆点在哪儿？如果最后项目失败了，最可能是哪些地方出了问题？这样的思考也充满了乐趣。

关于好奇心的重要性，怎么强调都不为过。尤其是在工作了一段时间之后，好奇心往往最先被消磨：流程变得熟悉、问题开始重复、注意力被琐碎事务和压力不断切割，慢慢地，我们便不再追问「为什么」。

为了对抗这种精神熵增，我总结了一套简单易行的思维训练法。通过四种「角色扮演」模式，强制切换视角，外加一个通用框架作为辅助工具，帮助我们找回对世界的敏锐度。

1. ET 模式（外星人视角）：对抗「习以为常」

核心理念：去熟悉化（Vuja De）

我们常说 Déjà vu（既视感），即对陌生环境感到熟悉；而 ET 模式追求的是完全相反的状态——Vuja De（未视感）。即：面对最熟悉的事物，强迫自己把它当成第一次见到，甚至完全不理解其用途。

• 「火星人观察报告」：尝试描述一件日常小事，但不使用约定俗成的名词。以「开会」为例，如果剥离掉「会议」这个概念，在 ET 眼中看到的是：一群碳基生物围坐在一张木板旁，地位最高的雄性发出声波，其余低阶生物低头在发光的玻璃板上快速移动手指。洞察：这种视角的价值在于剥离了社会强加给事物的「功能固着」。当不再把「低效的会议」理所当然地看作「工作流程」，才更有可能发现其本质——比如「信息传递效率极低」，进而思考：为什么不直接进行脑电波传输（发文档）？
• 「为什么追问链」：因为 ET 从没见过地球的物品，所以一切都值得质疑。顺着这个逻辑链条深挖：为什么手机屏幕是长方形的？（为了适应手掌抓握）；为什么一定要手持？（因为要随时观看）；为什么一定要用眼睛看？（目前的信息交互受限于视觉）。这种像孩子一样的连续追问（比如我小时就很好奇，为什么大人们打招呼通常都是「饭吃了吗」），往往能带我们穿透表象，触达事物的底层逻辑或生理极限。

2. 福尔摩斯模式（侦探视角）：对抗「视而不见」

核心理念：观察而非仅仅「看见」

福尔摩斯有一句名言：「你只是在看，你没有在观察。」 (You see, but you do not observe.) 这个模式要求我们将模糊的现状清晰化，寻找因果链条和逻辑漏洞。

• 从废弃中寻找线索：最近在看《黑白大厨》时，注意到一个细节：评审白钟元注意到角落里有一碟被回收的、只吃了一半的牛肉。其他选手都没有注意到，他还拿起其中一块没被吃过的牛肉品尝，发现牛肉过于干柴。 这就是侦探视角——从被忽略的细节（剩菜）中反推过程（烹饪失误），进而挖掘出被掩盖的真相。
• 关注「沉默的证据」：除了看到的，还要关注没发生的。比如在福尔摩斯的《银色马》一案中，关键线索是「那只在晚上没有叫的狗」。因为狗没叫，所以牵走马的人一定是熟人。在工作中，如果能注意到「谁没有发声」、「哪个数据没有变化」，有时能发现比喧嚣表面更重要的信息。

3. 马尔科维奇模式（体验视角）：对抗「自我中心」

核心理念：深度沉浸与换位思考

概念源自电影《成为马尔科维奇》，主角通过一道暗门能直接进入马尔科维奇的大脑，透过他的眼睛看世界。在生活中，这个模式几乎随处可用。

比如在咖啡馆里，可以尝试切换视角：

• 作为店员：

  • 为什么选择这家店？
  • 需要哪些技能？
  • 如果跳槽，可能会去哪里？

• 作为老板：

  • 为什么选址在这里？
  • 与周围咖啡馆的差异是什么？
  • 收入、成本、利润结构大概如何？
  • 哪些地方还有改进空间？

看剧时同样适用。比如：如果我是《绝命毒师》里的老白，在被 Tuco 掳走、Tuco 又被杀之后，该如何解释自己的失踪，既合情合理，又不引起怀疑？

4. 爱迪生模式（实验视角）：对抗「光想不做」

核心理念：假设与验证

爱迪生代表的是实干派与实验精神。当对某个现象产生好奇，比如「为什么这类小红书帖子会火？」不只停留在分析。试着提出假设（可能是封面图夸张，也可能是标题引发焦虑），然后设计一个低成本的实验——发几篇不同风格的帖子去验证你的假设。在产品领域，这就是先做 Demo 验证可行性。唯有实验，才能将好奇心转化为确定的认知。

一个通用框架：3W2H

最后分享一个我自己经常使用的框架：3W2H。它是在黄金圈法则（Why–How–What）基础上的扩展，更适合日常思考。

以「电视」这个习以为常的物品为例：

• What（本质）：它是什么？是显示屏，还是家庭娱乐中心？
• Why（根源）：为什么我们需要电视？是为了获取信息，还是为了背景噪音？
• How（机制）：它的运作原理和组成是什么？
• How much（量化）：它的价格构成是怎样的？覆盖了多少人群？
• What if（假设）：如果世界上没有电视会怎样？有完美的替代品吗？

这套组合拳能迅速将一个单薄的概念拆解得立体而丰满，在短时间内建立对陌生领域的深度认知。

好奇心不仅是一种能力，更是一种对抗平庸的武器。当我们开启 ET 的眼睛，用福尔摩斯的大脑思考，钻进马尔科维奇的躯壳，并像爱迪生一样去动手实验时，原本枯燥乏味的世界就会立刻生动起来。

世界没有变，变的是我们看待世界的分辨率。希望这四种模式和工具，能帮你擦亮积灰的镜头，重新发现那个充满惊奇的「新世界」。

学车时我开的是手动挡，起初因为技术生疏，常搞得手忙脚乱，所以第一台车就直接选了自动挡。但开了几年，我开始追求那种完全掌控的驾驶感，于是又增购了一台手动挡。遗憾的是，随着交通日益拥堵，换挡的乐趣逐渐被疲惫抵消，最终这台车也被冷落。算起来，我已经快二十年没认真开过手动挡了，但内心深处，我仍会时不时地怀念那段“人车合一”的时光。