安踏：并购实现全球化的里程碑时刻（含算法面试原题）

站长

2024年03月11日 13:24 · 阅读数 5

IPO，Buyout

既是开年最大的 IPO，更是一笔华丽的 Buyout。

北京时间2月1日晚，亚玛芬体育（Amer Sports）正式登陆纽交所。

本次亚玛芬体育共募得 13 亿美元（自2023年9月以来全球规模最大IPO），发行市值 63 亿美元（约合 450 亿人民币）。

说亚玛芬体育开年大家会感到陌生。

那始祖鸟呢？

还陌生的话，那安踏呢？

一句话介绍它们之间的关系：始祖鸟是亚玛芬体育旗下拥有三个核心品牌之一，而亚玛芬体育则于 2019 年由安踏、方源资本、Chip Wilson 以及腾讯财团进行联合收购。

在收购过程中，安踏占绝对主导地位，当时亚玛芬体育每股作价 40 欧元，总收购价为 16 亿欧元（当时约合 371 亿人民币）。

其中安踏投资 15.43 亿欧元，占股 57.85%，方源资本持股 21.4%，Chip Wilson持股 20.65%，腾讯持股 5.63%。

更重要的是，2019 年的亚玛芬体育仍是一家面临亏损的公司，当中的始祖鸟也是作为阿迪达斯的被弃业务，被亚玛芬体育全资收购，从而进入亚玛芬体育。

而在被收购后的第二年 2020 年，亚玛芬体育就已经实现盈利（营收 24.46 亿美元，利润 1.25 亿美元），从 2020 到现在，营收仍逐年上升，在大中华的盈利占比更是节节攀升。

现在回头看，安踏的全球化道路无疑是成功的，而之所以能够成功，核心是运营能力。

安踏以并购作为开端，从以前的 FILA 到现在的亚玛芬体育。不仅扭亏为盈，更重要的完成了全人群+全赛道的覆盖，大大丰富产品线的同时，增强企业抗风险额能力。

...

回归主线。

来一道简单模拟题。

题目描述

平台：LeetCode

题号：2342

给你一个下标从 0 开始的数组 nums，数组中的元素都是正整数。

请你选出两个下标 i 和 j（i != j），且 nums[i] 的数位和与 nums[j] 的数位和相等。

请你找出所有满足条件的下标 i 和 j，找出并返回 nums[i] + nums[j] 可以得到的最大值。

示例 1：

输入：nums = [18,43,36,13,7]

输出：54

解释：满足条件的数对 (i, j) 为：
- (0, 2) ，两个数字的数位和都是 9 ，相加得到 18 + 36 = 54 。
- (1, 4) ，两个数字的数位和都是 7 ，相加得到 43 + 7 = 50 。
所以可以获得的最大和是 54 。

示例 2：

输入：nums = [10,12,19,14]

输出：-1

解释：不存在满足条件的数对，返回 -1 。

提示：

1<=nums.length<=1051 <= nums.length <= 10^51<=nums.length<=105
1<=nums[i]<=1091 <= nums[i] <= 10^91<=nums[i]<=109

模拟

既然每个 nums[i]nums[i]nums[i] 都对应一个具体的数位和，统计每个数位和的最大值和次大值，然后在所有数位和的最大值和次大值求和中取 max 即是答案。

利用 1<=nums[i]<=1091 <= nums[i] <= 10^91<=nums[i]<=109，我们知道数位和不会超过 9×9=819 \times 9 = 819×9=81，可直接起一个大小为 100×2100 \times 2100×2 的二维数组进行统计，val[x][0]val[x][0]val[x][0] 代表数位和为 xxx 的次大值，val[x][1]val[x][1]val[x][1] 代表数位和为 xxx 的最大值。

Java 代码：

class Solution {
    public int maximumSum(int[] nums) {
        int[][] val = new int[100][2];
        for (int x : nums) {
            int t = x, cur = 0;
            while (t != 0) {
                cur += t % 10;
                t /= 10;
            }
            if (x >= val[cur][1]) { // 最大沦为次大, 更新最大
                val[cur][0] = val[cur][1];
                val[cur][1] = x;
            } else if (x > val[cur][0]) { // 更新次大
                val[cur][0] = x;
            }
        }
        int ans = -1;
        for (int i = 0; i < 100; i++) {
            if (val[i][0] != 0 && val[i][1] != 0) ans = Math.max(ans, val[i][0] + val[i][1]);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int maximumSum(vector<int>& nums) {
        vector<vector<int>> val(100, vector<int>(2, 0));
        for (int x : nums) {
            int t = x, cur = 0;
            while (t != 0) {
                cur += t % 10;
                t /= 10;
            }
            if (x >= val[cur][1]) {
                val[cur][0] = val[cur][1];
                val[cur][1] = x;
            } else if (x > val[cur][0]) {
                val[cur][0] = x;
            }
        }
        int ans = -1;
        for (int i = 0; i < 100; i++) {
            if (val[i][0] != 0 && val[i][1] != 0) ans = max(ans, val[i][0] + val[i][1]);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def maximumSum(self, nums: List[int]) -> int:
        val = [[0, 0] for _ in range(100)]
        for x in nums:
            t, cur = x, 0
            while t != 0:
                cur += t % 10
                t //= 10
            if x >= val[cur][1]:
                val[cur][0], val[cur][1] = val[cur][1], x
            elif x > val[cur][0]:
                val[cur][0] = x
        ans = -1
        for i in range(100):
            if val[i][0] != 0 and val[i][1] != 0:
                ans = max(ans, val[i][0] + val[i][1])
        return ans

TypeScript 代码：

function maximumSum(nums: number[]): number {
    const val = Array.from({ length: 100 }, () => [0, 0]);
    for (const x of nums) {
        let t = x, cur = 0;
        while (t !== 0) {
            cur += t % 10;
            t = Math.floor(t / 10);
        }
        if (x >= val[cur][1]) {
            val[cur][0] = val[cur][1];
            val[cur][1] = x;
        } else if (x > val[cur][0]) {
            val[cur][0] = x;
        }
    }
    let ans = -1;
    for (let i = 0; i < 100; i++) {
        if (val[i][0] !== 0 && val[i][1] !== 0) ans = Math.max(ans, val[i][0] + val[i][1]);
    }
    return ans;
};

时间复杂度：O(nlog⁡m)O(n\log{m})O(nlogm)，其中 n=1e5n=1e5n=1e5 为 nums 长度，m=1e9m=1e9m=1e9 为 nums[i]nums[i]nums[i] 值域上界
空间复杂度：O(C)O(C)O(C)，其中 C=2×9×log⁡mC = 2 \times 9 \times \log{m}C=2×9×logm

模拟

更进一步，我们不需要记录次大值，仅记录某个“数对和”当前的最大值即可。

每次计算出当前 nums[i]nums[i]nums[i] 对应的数对 cur 后，检查 cur 是否已出现过，若出现过用两者之和更新答案，并用 nums[i]nums[i]nums[i] 来更新 cur 下的最大值。

该做法本质是用「遍历过程」代替「次大维护」。

Java 代码：

class Solution {
    public int maximumSum(int[] nums) {
        int[] val = new int[100];
        int ans = -1;
        for (int x : nums) {
            int t = x, cur = 0;
            while (t != 0) {
                cur += t % 10;
                t /= 10;
            }
            if (val[cur] != 0) ans = Math.max(ans, val[cur] + x);
            val[cur] = Math.max(val[cur], x);
        }
        return ans;       
    }
}

C++ 代码：

class Solution {
public:
    int maximumSum(vector<int>& nums) {
        vector<int> val(100, 0);
        int ans = -1;
        for (int x : nums) {
            int t = x, cur = 0;
            while (t != 0) {
                cur += t % 10;
                t /= 10;
            }
            if (val[cur] != 0) ans = max(ans, val[cur] + x);
            val[cur] = max(val[cur], x);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def maximumSum(self, nums: List[int]) -> int:
        val = [0] * 100
        ans = -1
        for x in nums:
            t, cur = x, 0
            while t != 0:
                cur += t % 10
                t //= 10
            if val[cur] != 0:
                ans = max(ans, val[cur] + x)
            val[cur] = max(val[cur], x)
        return ans

TypeScript 代码：

function maximumSum(nums: number[]): number {
    const val = Array(100).fill(0);
    let ans = -1;
    for (const x of nums) {
        let t = x, cur = 0;
        while (t !== 0) {
            cur += t % 10;
            t = Math.floor(t / 10);
        }
        if (val[cur] !== 0) ans = Math.max(ans, val[cur] + x);
        val[cur] = Math.max(val[cur], x);
    }
    return ans;
};

时间复杂度：O(nlog⁡m)O(n\log{m})O(nlogm)，其中 n=1e5n=1e5n=1e5 为 nums 长度，m=1e9m=1e9m=1e9 为 nums[i]nums[i]nums[i] 值域上界
空间复杂度：O(C)O(C)O(C)，其中 C=9×log⁡mC = 9 \times \log{m}C=9×logm

我是宫水三叶，每天都会分享算法题解，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的合集新基地 🎉🎉