NS 方程千禧年难题引学术争议，附 LeetCode 735 栈模拟

NS 方程

OpenAI 刚刚对外宣布，已经解决了 NS 方程这一千禧年难题。

从官方公布的消息看，它使用了一款比 GPT-6 Astra 更强大的未公开前沿大模型，联合约 10000 个并发协作的 AI Agent，总共耗时 88 小时完成证明。

随声明一起放出的，还有一份 166 页的完整数学推导论文，以及配套的 Lean 形式化数学验证代码。

NS 方程千禧年难题是克雷数学研究所七大千禧年难题之一，已经困扰数学界约 90 年，悬赏 100 万美元。

当然，OpenAI 表示会放弃申领这笔奖金，同时强调该成果的核心价值在于展示 AGI 正在成为推动前沿科学探索的引擎。

AI 模型全自主解决千禧年难题，学术圈先地震了一轮。

但很快，纽约大学数学家 Tristan Buckmaster 公开指控 OpenAI 在 NS 方程问题上存在学术掠夺，称其团队多年深耕的研究成果被截胡。学术圈又一次震动。

按照 Buckmaster 的说法，他与 Anthropic 研究员 Alpöge 长期深耕流体方程爆破问题，走的是一条极少有人涉足的「光滑外力驱动」研究路线。

这条技术路径极其小众，全球范围内几乎没有其他团队深耕。两人在这条路上耗时数年，反复推演和打磨。

同时，Buckmaster 和 Alpöge 长期使用 OpenAI 的 Codex 辅助推理，把大量核心思路、公式推演、论文草稿都留在了 Codex 的对话记录里。

但就在两人即将完成关键突破、敲定最终证明框架时，OpenAI 宣布攻克了 NS 方程，而且研究路线与 Buckmaster 一方高度雷同。

真相究竟如何，目前外界站 OpenAI 和 Buckmaster 的都有，后续也可能不会被大众完全知晓。

这件事对未来的学术人员来说，冲击和割裂感可能才刚刚开始：不使用模型配合研究，进度大概率会被追赶；使用模型配合研究，又可能面临被“截胡”的风险。

另外需要说明，虽然 OpenAI 的证明路线和 Buckmaster 雷同，但前者的欧拉结果是“无外力版本”，后者是“受迫版本”。前者难度更大，不过在极高算力面前，这一问题并不算突出。

后续候选解何时被承认、成果归属如何，最终得由克雷数学研究所这个裁判方来判断，而不是看网友如何站队。

只是没想到，人类和 AI 的学术争议，一上来就是千禧年级别，确实有点魔幻。

题目描述

平台：LeetCode

题号：735

给定一个整数数组 asteroids，表示在同一行的行星。

对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向：正表示向右移动，负表示向左移动。每一颗行星以相同的速度移动，找出碰撞后剩下的所有行星。

碰撞规则：

1. 两个行星相互碰撞，较小的行星会爆炸。
2. 如果两颗行星大小相同，则两颗行星都会爆炸。
3. 两颗移动方向相同的行星，永远不会发生碰撞。

示例 1：

输入：asteroids = [5,10,-5]

输出：[5,10]

解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2：

输入：asteroids = [8,-8]

输出：[]

解释：8 和 -8 碰撞后，两者都发生爆炸。

示例 3：

输入：asteroids = [10,2,-5]

输出：[10]

解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

模拟 + 栈

由于碰撞抵消总是从相邻行星之间发生，所以可以使用「栈」来模拟这一过程。

从前往后处理所有的 asteroids，并借助栈存储当前未被抵消的行星。当栈顶元素方向往右、当前 asteroids 方向往左时，就会触发抵消操作，按碰撞规则处理即可。

Java 代码：

class Solution {
public int[] asteroidCollision(int[] asteroids) {
        Deque<Integer> d = new ArrayDeque<>();
for (int t : asteroids) {
boolean ok = true;
while (ok && !d.isEmpty() && d.peekLast() > 0 && t < 0) {
int a = d.peekLast(), b = -t;
if (a <= b) d.pollLast();
if (a >= b) ok = false;
            }
if (ok) d.addLast(t);
        }
int sz = d.size();
int[] ans = new int[sz];
while (!d.isEmpty()) ans[--sz] = d.pollLast();
return ans;
    }
}

C++ 代码：

class Solution {
public:
vector<int> asteroidCollision(vector<int>& asteroids) {
deque<int> d;
for (int t : asteroids) {
bool ok = true;
while (ok && !d.empty() && d.back() > 0 && t < 0) {
int a = d.back(), b = -t;
if (a <= b) d.pop_back();
if (a >= b) ok = false;
            }
if (ok) d.push_back(t);
        }
vector<int> ans(d.begin(), d.end());
return ans;
    }
};

Python 3 代码：

class Solution:
    def asteroidCollision(self, asteroids: List[int]) -> List[int]:
        stk = []
for t in asteroids:
            ok = True
while ok and stk and stk[-1] > 0 and t < 0:
                a, b = stk[-1], -t
if a <= b:
                    stk.pop(-1)
if a >= b:
                    ok = False
if ok:
                stk.append(t)
return stk

TypeScript 代码：

function asteroidCollision(asteroids: number[]): number[] {
const stk = new Array<number>()
for (const t of asteroids) {
let ok = true
while (ok && stk.length > 0 && stk[stk.length - 1] > 0 && t < 0) {
const a = stk[stk.length - 1], b = -t
if (a <= b) stk.pop()
if (a >= b) ok = false
        }
if (ok) stk.push(t)
    }
return stk
};

时间复杂度：O(n)

空间复杂度：O(n)

本文由 云栈社区 整理编辑，仅作技术交流。