DeepSeek梁文锋身价超越OpenAI奥特曼，两倍都不止了。。

需要注意的是，造成财富差异的主要原因，并不是 DeepSeek 的估值比 OpenAI 更高（实际上 OpenAI 的估值是 DeepSeek 的十倍），而是梁文锋持有 DeepSeek 的股份更为集中（高达 80%）。从这个榜单可以看出，"年长"一代的企业家，往往是依靠国民级的实业产品（如农夫山泉）取得财富，而"年轻"一代企业家，则是靠国民级的平台产品（微信、抖音）来获取财富。但无论如何，最早的

宫水三叶的刷题日记

697人浏览 · 2025-03-28 15:03:19

宫水三叶的刷题日记 · 2025-03-28 15:03:19 发布

富豪榜

昨天（3月27日），最新的「胡润全球富豪榜」出炉，结合早些时候公布的「彭博亿万富豪指数」以及「福布斯富豪榜」，主流的各大富豪榜都更新完毕了。

不同的榜单对于富豪们的身价估算稍有出入，但富豪之间的相对排名出入不大。

大白话就是，这些榜单并不知道富豪们的准确身价（大概率连富豪自己都不知道，身价往往随股价波动较大），但富豪们之间谁更有钱，还是知道的。

以福布斯富豪榜的数据为例，字节跳动的创始人张一鸣（42 岁）以 655 亿美元，登顶中国首富（全球第 23 位）。腾讯的马化腾（54 岁）以 535 亿美元位列中国第二（全球第 27 位），农夫山泉的钟睒睒（71 岁）以 531 亿美元位列中国第三（全球第 28 位）。

从这个榜单可以看出，"年长"一代的企业家，往往是依靠国民级的实业产品（如农夫山泉）取得财富，而"年轻"一代企业家，则是靠国民级的平台产品（微信、抖音）来获取财富。

财富的流动，是从"实业"到"互联网"的，这一规律在一些新晋的富豪们中，更为明显。

例如，DeepSeek 创始人梁文锋（40 岁），本次以 46 亿美元的身价首次上榜，而海外巨头 OpenAI 的创始人奥特曼（39 岁），身价为 18 亿美元，只有梁文锋一半不到。

需要注意的是，造成财富差异的主要原因，并不是 DeepSeek 的估值比 OpenAI 更高（实际上 OpenAI 的估值是 DeepSeek 的十倍），而是梁文锋持有 DeepSeek 的股份更为集中（高达 80%）。

但无论如何，最早的「实业」，近二十年的「移动互联网」，未来的「AI」，都是明确的，使财富流动的路径。

对此，你怎么看？欢迎评论区交流。

...

回归主题。

来一道和「字节跳动-校招」相关的算法题

题目描述

平台：LeetCode

题号：1711

大餐是指恰好包含两道不同餐品的一餐，其美味程度之和等于 2 的幂。

你可以搭配任意两道餐品做一顿大餐。

给你一个整数数组 deliciousness，其中 deliciousness[i] 是第 i 道餐品的美味程度，返回你可以用数组中的餐品做出的不同大餐的数量，结果需要对取余。

注意，只要餐品下标不同，就可以认为是不同的餐品，即便它们的美味程度相同。

示例 1：

输入：deliciousness = [1,3,5,7,9]

输出：4

解释：大餐的美味程度组合为 (1,3) 、(1,7) 、(3,5) 和 (7,9) 。
它们各自的美味程度之和分别为 4 、8 、8 和 16 ，都是 2 的幂。

示例 2：

输入：deliciousness = [1,1,1,3,3,3,7]

输出：15

解释：大餐的美味程度组合为 3 种 (1,1) ，9 种 (1,3) ，和 3 种 (1,7) 。

提示：

枚举前一个数（TLE）

一个朴素的想法是，从前往后遍历中的所有数，当遍历到下标的时候，回头检查下标小于的数是否能够与相加形成的幂。

这样的做法是的，防止同样的数值被重复计算，我们可以使用「哈希表」记录某个数出现了多少次，但这并不改变算法仍然是的。

而且我们需要一个 check 方法来判断某个数是否为的幂：

朴素的做法是对应用试除法，当然因为精度问题，我们需要使用乘法实现试除；
另一个比较优秀的做法是利用位运算找到符合「大于等于」的最近的的幂，然后判断是否与相同。

两种做法差距有多大呢？方法一的复杂度为，方法二为。

根据数据范围，方法一最多也就是执行不超过次循环。

显然，采用何种判断的幂的做法不是关键，在 OJ 判定上也卡在 TLE 上。

「但通过这样的分析，我们可以发现「枚举前一个数」的做法是与相关的，而枚举「可能出现的的幂」则是有明确的范围，这引导出我们的解法二。」

代码：

class Solution {
    int mod = (int)1e9+7;
    public int countPairs(int[] ds) {
        int n = ds.length;
        long ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            int x = ds[i];
            for (int other : map.keySet()) if (check(other + x)) ans += map.get(other);
            map.put(x, map.getOrDefault(x, 0) + 1);
        }
        return (int)(ans % mod);
    }
    boolean check(long x) {
        // 方法一
        // long cur = 1;
        // while (cur < x) {
        //     cur = cur * 2;
        // }
        // return cur == x;
        
        // 方法二
        return getVal(x) == x;
    }
    long getVal(long x) {
        long n = x - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return n < 0 ? 1 : n + 1;
    }
}

时间复杂度：
空间复杂度：

枚举 2 的幂（容斥原理）

根据对朴素解法的分析，我们可以先使用「哈希表」对所有在出现过的数进行统计。

然后对于每个数，检查所有可能出现的的幂，再从「哈希表」中反查是否存在，并实现计数。

一些细节：如果哈希表中存在，并且，这时候方案数应该是；其余一般情况则是。

同时，这样的计数方式，我们对于二元组会分别计数两次（遍历和遍历），因此最后要利用容斥原理，对重复计数的进行减半操作。

Java 代码：

class Solution {
    int mod = (int)1e9+7, max = 1 << 22;
    public int countPairs(int[] ds) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int d : ds) map.put(d, map.getOrDefault(d, 0) + 1);
        long ans = 0;
        for (int x : map.keySet()) {
            for (int i = 1; i < max; i <<= 1) {
                int t = i - x;
                if (map.containsKey(t)) {
                    if (t == x) ans += (map.get(x) - 1) * 1L * map.get(x);
                    else ans += map.get(x) * 1L * map.get(t);
                }
            }
        }
        ans >>= 1;
        return (int)(ans % mod);
    }
}

C++ 代码：

class Solution {
public:
    int countPairs(vector<int>& ds) {
        int mod = 1e9 + 7, maxv = 1 << 22;
        unordered_map<int, int> freq;        
        for (int d : ds) freq[d]++;
        long long ans = 0;
        for (auto& [x, cnt] : freq) {
            for (int i = 1; i < maxv; i <<= 1) {
                int t = i - x;
                if (freq.count(t)) {
                    if (t == x) ans += (cnt - 1LL) * cnt;
                    else ans += cnt * 1LL * freq[t];
                }
            }
        }
        ans >>= 1;
        return ans % mod;
    }
};

Python 代码：

class Solution:
    def countPairs(self, ds: List[int]) -> int:
        mod, maxv = 10**9 + 7, 1 << 22
        count = defaultdict(int)
        for d in ds:
            count[d] += 1
        ans = 0
        for x, cnt in count.items():
            i = 1
            while i < maxv:
                t = i - x
                if t in count:
                    if t == x:
                        ans += (cnt - 1) * cnt
                    else:
                        ans += cnt * count[t]
                i <<= 1
        return (ans >> 1) % mod

时间复杂度：根据数据范围，令为。复杂度为
空间复杂度：

枚举 2 的幂（边遍历边统计）

当然，我们也可以采取「一边遍历一边统计」的方式，这样取余操作就可以放在遍历逻辑中去做，也就顺便实现了不使用来计数（以及不使用 % 实现取余）。

代码：

class Solution {
    public int countPairs(int[] ds) {
        int mod = (int)1e9+7, max = 1 << 22, ans = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int x : ds) {
            for (int i = 1; i < max; i <<= 1) {
                int t = i - x;
                if (map.containsKey(t)) {
                    ans += map.get(t);
                    if (ans >= mod) ans -= mod;
                }
            }
            map.put(x, map.getOrDefault(x, 0) + 1);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int countPairs(vector<int>& ds) {
        int mod = 1e9 + 7, maxv = 1 << 22, ans = 0;
        unordered_map<int, int> freq;
        for (int x : ds) {
            for (int i = 1; i < maxv; i <<= 1) {
                int t = i - x;
                if (freq.count(t)) {
                    ans = (ans + freq[t]) % mod;
                }
            }
            freq[x]++;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def countPairs(self, ds: List[int]) -> int:
        mod, maxv, ans = 10**9 + 7, 1 << 22, 0
        freq = defaultdict(int)
        for x in ds:
            i = 1
            while i < maxv:
                t = i - x
                if t in freq:
                    ans = (ans + freq[t]) % mod
                i <<= 1
            freq[x] += 1
        return ans