DeepSeek 出现的最大意义，是让老美意识到"闭源"死路一条

宫水三叶的刷题日记

发布于 2025-02-05 16:43:35

7600

代码可运行

文章被收录于专栏：宫水三叶的刷题日记宫水三叶的刷题日记

运行总次数：0

代码可运行

OpenAI

因为 DeepSeek 的崛起，导致 OpenAI 坐不住了。

虽然 OpenAI 的创始人兼 CEO 奥特曼曾在推特上大方表示：像 DeepSeek 这样的对手的出现，让他们感到兴奋，马上他们也会发布更好的模型。

于是在昨天凌晨，OpenAI 发布了全新推理模型 o3-mini：

甚至是免费提供 o3-mini 给用户使用，这也是 ChatGPT 首次向所有用户免费提供推理模型。

但又正如你现在也没有听说多少关于 o3-mini 的新闻那样，这个新模型的发布，更多只是 OpenAI 一方"自认为的大招"，并未在 AI 圈掀起多少波澜 🤣🤣🤣

虽然 o3-min 不怎么样，但在 OpenAI 和奥特曼这段时间的丝滑小连招中，给外界传递了一个重磅信息：OpenAI 将重新考虑开源。

好家伙，这才是 DeepSeek 对世界的重大意义 👍👍

在最近一次的 Reddit（老美的贴吧）问答中，奥特曼表示：OpenAI 在开源问题上一直处于"历史错误的一边"，需要制定不同的开源策略。

众所周知，OpenAI 中的 Open 一定程度就是指 "OpenSource 开源"，旨在通过开源促进 AI 技术共享，早期他们也确实开源了部分 GPT 的版本（比如 2019 年开源了 GPT-2 的部分版本），但自从 ChatGPT 爆火之后，开源的工作他们就彻底不做了，也开始自主摘掉"非盈利性"的帽子，转而考虑融资和盈利问题。

这也是世界首富（同时也是 OpenAI 的早期投资人）马斯克一直吐槽的事儿：OpenAI 前期打着"推动世界 AI 发展"的口号，拿了不少捐赠和资源，等到小有成绩的时候，就开始盘算如何"藏着捏着"来大赚一笔。

如今 DeepSeek 的出现，已经打破了 OpenAI 领先业界的局面。

奥特曼现在公开表示重新考虑"开源问题"，并不是良心发现，而是深切知道，差距在缩小，如果再坚持"闭源"将会死路一条。

相比于让大家免费使用上推理模型，能让 OpenAI 重新考虑开源，才是 DeepSeek 对这个世界而言的最大意义。

...

年初五接财神，祝大家 2025 财源广进。

继续安排一道简单算法题。

题目描述

平台：LeetCode

题号：553

给定一组正整数，相邻的整数之间将会进行浮点除法操作。

例如， [2,3,4] -> 2 / 3 / 4。

但是，你可以在任意位置添加任意数目的括号，来改变算数的优先级。

你需要找出怎么添加括号，才能得到最大的结果，并且返回相应的字符串格式的表达式。

你的表达式不应该含有冗余的括号。

示例：

输入: [1000,100,10,2]

输出: "1000/(100/10/2)"

解释:
1000/(100/10/2) = 1000/((100/10)/2) = 200
但是，以下加粗的括号 "1000/((100/10)/2)" 是冗余的，
因为他们并不影响操作的优先级，所以你需要返回 "1000/(100/10/2)"。

其他用例:
1000/(100/10)/2 = 50
1000/(100/(10/2)) = 50
1000/100/10/2 = 0.5
1000/100/(10/2) = 2

说明:

输入数组的长度在

[1, 10]

之间。

数组中每个元素的大小都在

[2, 1000]

之间。

每个测试用例只有一个最优除法解。

数学 + 贪心

我们假定取得最优解的表示为

\frac{a}{b}

，可以留意到任意的

nums[i]

的范围为

[2, 1000]

，因此我们应当让尽可能多的

nums[i]

参与

（分子）的构建中。

因此一种可以构成最优表示的方式为「将除第一位以外的所有数作为一组，进行连除（转乘法），从而将所有可以变成分子的数都参与到

的构建中」。

即有：

\frac{nums[0]}{nums[1] / nums[2] / ... / nums[n - 1]} = \frac{nums[0]}{nums[1] \times \frac{1}{nums[2]} \times ... \times \frac{1}{nums[n - 1]}} = \frac{nums[0] \times nums[2] \times ... \times nums[n - 1]}{nums[1]}

综上，我们只需要从前往后进行构建出连除的答案，如果

nums

的长度大于

，再追加一对大括号即可。

[a_0, a_1, ... , a_n]

a_0/a_1/.../a_n

a_0/(a_1/.../a_n)

Java 代码：

class Solution {
    public String optimalDivision(int[] nums) {
        int n = nums.length;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            sb.append(nums[i]);
            if (i + 1 < n) sb.append("/");
        }
        if (n > 2) {
            sb.insert(sb.indexOf("/") + 1, "(");
            sb.append(")");
        }
        return sb.toString();
    }
}

C++ 代码：

class Solution {
public:
    string optimalDivision(vector<int>& nums) {
        int n = nums.size();
        string ans;
        for (int i = 0; i < n; i++) {
            ans += to_string(nums[i]);
            if (i + 1 < n) ans += "/";
        }
        if (n > 2) {
            ans.insert(ans.find("/") + 1, "(");
            ans += ")";
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def optimalDivision(self, nums: List[int]) -> str:
        n = len(nums)
        ans = ''
        for i in range(n):
            ans += str(nums[i])
            if i + 1 < n:
                ans += '/'
        if n > 2:
            idx = ans.find('/') + 1
            ans = ans[:idx] + '(' + ans[idx:]
            ans += ')'
        return ans

TypeScript 代码：

function optimalDivision(nums: number[]): string {
    const n = nums.length;
    let ans = '';
    for (let i = 0; i < n; i++) {
        ans += nums[i].toString();
        if (i + 1 < n) ans += '/';
    }
    if (n > 2) {
        const idx = ans.indexOf('/') + 1;
        ans = ans.substring(0, idx) + '(' + ans.substring(idx);
        ans += ')';
    }
    return ans;
};