从"阿里握手苹果"谈"DeepSeek对中美科技公司影响"

阿里 x iPhone

昨天傍晚，马云再度现身杭州阿里园区。

具体一点的，是阿里西溪园区，再具体一点的，是阿里西溪园区A区2号楼的闲鱼。

和此前的马云露脸不同，这次的出现更加突然，几乎就是"毫无预兆"。

不少在阿里的小伙伴前一秒都还坐在工位上，下一秒抬头就看到了马老师，整个过程突然而又迅速，大家都没来得及站起来跟马老师打招呼。

再晚一点，一则在预料之中的消息正式公布了。

苹果已经与阿里巴巴达成合作，共同为中国 iPhone 用户开发 Apple Intelligence 及相关 AI 功能

目前，绝大多数国家的 iPhone 都已经用搭配上了由 OpenAI 提供的 AI 功能，但国行版本在这方面一直是缺失的，这也导致了 iPhone 16 系列在大中华区销量，同比下降了 18.2%。

此前一直传言，苹果和百度走得很近，文心一言有可能会成为国行 iPhone 的 AI 服务商。

再之后，另外一个坏消息出来了：除了百度的 AI 表现不能让苹果满意以外，在"用户隐私"方面，双方也产生了很大的分歧，合作翻车了。

之后苹果的股价开始下跌，这里除了有「巴菲特老爷子卖出苹果」的领头效应以外，还包含了外界并不看好苹果能解决国行 iPhone 销量下降问题，更不看好 AI 时代的 Apple Intelligence。

直到春节，这一切才开始发生了变化，而导致变化的，是 DeepSeek 的出现。

是的，这事儿还和 DeepSeek 有关系。

如果说 DeepSeek 的出现，对美国哪家公司最有利，那一定是苹果，对哪家公司最不利，则是 OpenAI。

DeepSeek 的出现，证明了 AI 的护城河可以很窄，作为在 AI 领域一直处于落后的苹果，未来反超的机会很大，而且 DeepSeek 出自中国公司，有效填补了国行 iPhone 的 AI 技术供应商缺失问题。

看到这里，可能有读者会问：那 DeepSeek 的出现，对哪家公司来说，是最大的利好，对哪家公司来说，又是最大的利空呢？

最大的利好，是小米。

小米的处境和苹果是类似的，在国内 AI 领域里面，它并不属于第一梯队。小米股价上涨，更多的是因为小米汽车的成功。

DeepSeek 的出现，意味着小米的落后可能会被抹平，同时开源模型的领先水平，利用得好，有可能会让小米的智驾也挤进第一梯队。

短版变长，长版变更长。这是 DeepSeek 出现后，我更加看好小米的逻辑。

那对哪家中国公司最不利？

毫无疑问是「字节豆包/百度文心一言」此类一直按照 OpenAI 技术路线砸钱做模型，而且是只做模型，不做应用场景的纯软件公司。

说到这里，那为什么苹果没有选择 DeepSeek 作为合作伙伴呢？

是被阿里截胡了吗？并不是，苹果也接触并使用了 DeepSeek，但选择的是阿里。

很简单，因为阿里更强。

你没看错，我的说就是阿里比 DeepSeek 更强，但阿里的强，是站在了 DeepSeek 的肩膀上的。

在 DeepSeek 发布了惊为天人的「DeepSeek-R1」的第二天晚上，阿里就发布了自己的「通义千问 2.5 Max」大模型，就是在借鉴 DeepSeek 的思路上做的，水平还略高于「DeepSeek-R1」。

而且阿里在 AI 领域的强，并不是只体现在这个 2.5 Max 版本上，他们在开源领域一直处于领跑地位，且开放性最高，基于通义千问大模型微调出来的小模型，早就破万，几乎是全领域覆盖。

所以，苹果选择阿里完全是情理之中的决定。

能够得到苹果的青睐，是对阿里 AI 的肯定，这也给了资本重新审视阿里的理由。

这对于这几年主营业务被拼多多和抖音打得节节败退的阿里来说，是个很好的机会。

但阿里能基于 DeepSeek，别的公司也可以，就看在阿里能否再叠加自己一直以来在 AI 上的积累，好好守擂，重新成为 TOP 级别的科技公司。

对此，你怎么看？

...

回归主题。

来一道和「阿里巴巴」校招相关的算法题。

题目描述

平台：LeetCode

题号：1001

在大小为 n x n 的网格 grid 上，每个单元格都有一盏灯，最初灯都处于 关闭 状态。

给你一个由灯的位置组成的二维数组 lamps，其中 $lamps[i] = [row_i, col_i]$ 表示 打开 位于 grid[rowi][coli] 的灯。即便同一盏灯可能在 lamps 中多次列出，不会影响这盏灯处于 打开 状态。

当一盏灯处于打开状态，它将会照亮 自身所在单元格 以及同一 行 、同一 列 和两条 对角线 上的 所有其他单元格 。

另给你一个二维数组 queries，其中 $queries[j] = [row_j, col_j]$ 。对于第 $j$ 个查询，如果单元格 $[row_j, col_j]$ 是被照亮的，则查询结果为 $1$ ，否则为 $0$ 。

在第 j 次查询之后 [按照查询的顺序] ，关闭 位于单元格 $grid[row_j][col_j]$ 上及相邻 $8$ 个方向上（与单元格 $grid[row_i][col_i]$ 共享角或边）的任何灯。

返回一个整数数组 ans 作为答案， ans[j] 应等于第 j 次查询 queries[j] 的结果，$1$ 表示照亮，$0$ 表示未照亮。

示例 1：

输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]

输出：[1,0]

解释：最初所有灯都是关闭的。在执行查询之前，打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮（蓝色方框）。该单元格被照亮，所以 ans[0] = 1 。然后，关闭红色方框中的所有灯。

第 1 次查询检查 grid[1][0] 是否被照亮（蓝色方框）。该单元格没有被照亮，所以 ans[1] = 0 。然后，关闭红色矩形中的所有灯。

示例 2：

输入：n = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]

输出：[1,1]

示例 3：

输入：n = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]

输出：[1,1,0]

提示：

• $1 <= n <= 10^9$
• $0 <= lamps.length <= 20000$
• $0 <= queries.length <= 20000$
• $lamps[i].length = 2$
• $0 <= row_i, col_i < n$
• $queries[j].length = 2$
• $0 <= row_j, col_j < n$

哈希表 + 线映射

棋盘大小的数据范围为 $n = 10^9$，硬模拟「亮灯」的操作必然会 TLE，而 lamps 和 queries 数据范围为 $20000$ 是一个较为常见的突破口。

由于点亮每一盏灯，可以使得当前 行、列 和 对角线 的位置被照亮，行列可直接使用棋盘坐标的 $(x, y)$ 来代指，而对角线则可以使用「截距」来进行代指，即使用 $x + y$ 和 $x - y$ 进行代指。

分别使用四个「哈希表」row、col、left 和 right 来记录 行、列 和 对角线 的点亮情况（key 为线编号，value 为点亮次数）。

这样我们可以在 $O(1)$ 的复杂度处理掉所有的 $lamps[i]$，某个位置被照亮的充要条件为：「当前位置所在行被点亮」或「当前位置所在列被点亮」或「当前位置所处的对角线被点亮」。

同时，由于每次查询后要进行「灭灯」操作（注意：灭灯只能灭有灯的位置，而不是灭有光的位置 🤣），因此我们还需要另外记录每个灯的位置，可以使用利用「二维转一维」的技巧进行编号：$idx = x \times n + y$，并使用 HashSet 进行记录（忽略重复的 $lamps[i]$）。

由于询问次数最多为 $20000$，因此直接在查询完成后模拟「灭灯」即可（访问自身及相邻格子，共 $9$ 个），计算量为 $2 \times 10^5$ 以内，可以接受。若某个位置存在灯，将其从 HashSet 中移除，并更新对应线的点亮情况。

Java 代码：

class Solution {
    int[][] dirs = new int[][]{{0,0},{0,-1},{0,1},{-1,0},{-1,-1},{-1,1},{1,0},{1,-1},{1,1}};
    public int[] gridIllumination(int n, int[][] lamps, int[][] queries) {
        long N = n;
        Map<Integer, Integer> row = new HashMap<>(), col = new HashMap<>();
        Map<Integer, Integer> left = new HashMap<>(), right = new HashMap<>();
        Set<Long> set = new HashSet<>();
        for (int[] l : lamps) {
            int x = l[0], y = l[1];
            int a = x + y, b = x - y;
            if (set.contains(x * N + y)) continue;
            increment(row, x); increment(col, y);
            increment(left, a); increment(right, b);
            set.add(x * N + y);
        }
        int m = queries.length;
        int[] ans = new int[m];
        for (int i = 0; i < m; i++) {
            int[] q = queries[i];
            int x = q[0], y = q[1];
            int a = x + y, b = x - y;
            if (row.containsKey(x) || col.containsKey(y) || left.containsKey(a) || right.containsKey(b)) ans[i] = 1;

            for (int[] d : dirs) {
                int nx = x + d[0], ny = y + d[1];
                int na = nx + ny, nb = nx - ny;
                if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
                if (set.contains(nx * N + ny)) {
                    set.remove(nx * N + ny);
                    decrement(row, nx); decrement(col, ny);
                    decrement(left, na); decrement(right, nb);
                }
            }
        }
        return ans;
    }
    void increment(Map<Integer, Integer> map, int key) {
        map.put(key, map.getOrDefault(key, 0) + 1);
    }
    void decrement(Map<Integer, Integer> map, int key) {
        if (map.get(key) == 1) map.remove(key);
        else map.put(key, map.get(key) - 1);
    }
}

• 时间复杂度：令 $lamps$ 长度为 $a$，$queries$ 长度为 $b$，处理所有的 $lamp[i]$ 复杂度为 $O(a)$，处理所有的 $queries[j]$ 复杂度为 $O(C \times b)$，其中 $C$ 为模拟灭灯时所联通的格子数量，固定为 $9$。整体复杂度为 $O(a + C \times b)$
• 空间复杂度：$O(a)$