国内首家吹响"反卷"号角的大厂出现了

宫水三叶的刷题日记
253 阅读9分钟

去哪儿

昨天（7月9日）去哪儿 CEO 陈刚发布了全员信：从7月15日开始，每周三和周五，员工可灵活选择办公地点。

陈刚在信中强调，员工按规定混合办公，无需任何申请审批。

消息一出，网友横竖分成了两派。

支持派纷纷发来贺电：

不少网友还表示，去哪儿网是好企业，以后（价格相同的情况下）优先使用去哪儿网。

不得不说，网友是懂前提的，连空白承诺都整这么严谨 🤣

另外一派，我愿称之为"担忧派"，认为「灵活办公」和「24小时待命」没有区别：

emmmm

怎么说呢，之所以给这一派加上双引号，不是认为这些担心不会发生，反而是已经发生。

觉得「灵活办公」和「24小时待命」没有区别的网友，大致是还没体会过国内大厂的工作节奏。

如果是卷味十足的企业，即使你在公司办公加班到十点，回到家电话还是会响起。

不管去哪儿，是真的如信中所说，是出于对员工 WLB（工作和生活平衡）的考虑；还是单纯因为看到正面数据，认为做这事的收益大于成本，可以全面铺开实现利益最大化；还是只是为了在内卷当道的时代出个名 ...

这都是一个很好的示范。

无论是极致追求效率的互联网行业，还是其他已经身处白热化的赛道，都太需要这个示范了。

我们究竟是要回归到 30 年前的，利用所谓的「大力出奇迹」原理，通过引入 100% 的内卷来挤出 1% 的增速/利润，还是说应该回归到"人"本身，通过非压迫的方式，让大家真正的凝聚在一起，从而提高整体的战斗力。

这是每个人都需要思考的问题。

...

回归主题。

来一道简简单单算法题。

题目描述

平台：LeetCode

题号：1713

给你一个数组 target，包含若干互不相同的整数，以及另一个整数数组 arr，arr 可能包含重复元素。

每一次操作中，你可以在 arr 的任意位置插入任一整数。

比方说，如果 arr = [1,4,1,2]，那么你可以在中间添加 3 得到 [1,4,3,1,2] 。

你可以在数组最开始或最后面添加整数。

请你返回最少操作次数，使得 target 成为 arr 的一个子序列。

一个数组的子序列指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的子序列（加粗元素），但 [2,4,2] 不是子序列。

示例 1：

输入：target = [5,1,3], arr = [9,4,2,3,4]

输出：2

解释：你可以添加 5 和 1 ，使得 arr 变为 [5,9,4,1,2,3,4] ，target 为 arr 的子序列。

示例 2：

输入：target = [6,4,8,1,3,2], arr = [4,7,6,2,3,8,6,1]

输出：3

提示：

  • 1<=target.length,arr.length<=1051 <= target.length, arr.length <= 10^5
  • 1<=target[i],arr[i]<=1091 <= target[i], arr[i] <= 10^9
  • target 不包含任何重复元素。

基本分析

为了方便，我们令 target 长度为 n，arr 长度为 m，target 和 arr 的最长公共子序列长度为 max，不难发现最终答案为 n - max。

因此从题面来说，这是一道最长公共子序列问题（LCS）。

但朴素求解 LCS 问题复杂度为 O(n×m)O(n \times m)，使用状态定义「f[i][j]f[i][j] 为考虑 a 数组的前 i 个元素和 b 数组的前 j 个元素的最长公共子序列长度为多少」进行求解。

而本题的数据范围为 10^5，使用朴素求解 LCS 的做法必然超时。

一个很显眼的切入点是 target 数组元素各不相同，当 LCS 问题增加某些条件限制之后，会存在一些很有趣的性质。

其中一个经典的性质就是：当其中一个数组元素各不相同时，最长公共子序列问题（LCS）可以转换为最长上升子序列问题（LIS）进行求解。同时最长上升子序列问题（LIS）存在使用「维护单调序列 + 二分」的贪心解法，复杂度为 O(nlog⁡n)O(n\log{n})。

因此本题可以通过「抽象成 LCS 问题」->「利用 target 数组元素各不相同，转换为 LIS 问题」->「使用 LIS 的贪心解法」，做到 O(nlog⁡n)O(n\log{n}) 的复杂度。

基本方向确定后，我们证明一下第 2 步和第 3 步的合理性与正确性。

证明

1. 为何其中一个数组元素各不相同，LCS 问题可以转换为 LIS 问题？

本质是利用「当其中一个数组元素各不相同时，这时候每一个“公共子序列”都对应一个不重复元素数组的下标数组“上升子序列”，反之亦然」。

我们可以使用题目给定的两个数组（target 和 arr）理解上面的话。

由于 target 元素各不相同，那么首先 target 元素和其对应下标，具有唯一的映射关系。

然后我们可以将重点放在两者的公共元素上（忽略非公共元素），每一个“公共子序列”自然对应了一个下标数组“上升子序列”，反之亦然。

注意：下图只画出了两个数组的某个片段，不要错误理解为两数组等长。

如果存在某个“公共子序列”，根据“子序列”的定义，那么对应下标序列必然递增，也就是对应了一个“上升子序列”。

反过来，对于下标数组的某个“上升子序列”，首先意味着元素在 target 出现过，并且出现顺序递增，符合“公共子序列”定义，即对应了一个“公共子序列”。

至此，我们将原问题 LCS 转换为了 LIS 问题。

2. 贪心求解 LIS 问题的正确性证明？

朴素的 LIS 问题求解，我们需要定义一个 f[i]f[i] 数组代表以 nums[i]nums[i] 为结尾的最长上升子序列的长度为多少。

对于某个 f[i]f[i] 而言，我们需要往回检查 [0,i−1][0, i - 1] 区间内，所有可以将 nums[i]nums[i] 接到后面的位置 j，在所有的 f[j]+1f[j] + 1 中取最大值更新 f[i]f[i]。因此朴素的 LIS 问题复杂度是 O(n2)O(n^2) 的。

LIS 的贪心解法则是维护一个额外 g 数组，g[len]=xg[len] = x 代表上升子序列长度为 len 的上升子序列的「最小结尾元素」为 x。

整理一下，我们总共有两个数组：

  • f 动规数组：与朴素 LIS 解法的动规数组含义一致。f[i]f[i] 代表以 nums[i]nums[i] 为结尾的上升子序列的最大长度；
  • g 贪心数组：g[len]=xg[len] = x 代表上升子序列长度为 len 的上升子序列的「最小结尾元素」为 x。

由于我们计算 f[i]f[i] 时，需要找到满足 nums[j]<nums[i]nums[j] < nums[i]，同时取得最大 f[j]f[j] 的位置 j。

我们期望通过 g 数组代替线性遍历。

显然，如果 g 数组具有「单调递增」特性的话，我们可以通过「二分」找到符合 g[idx]<nums[i]g[idx] < nums[i] 分割点 idx（下标最大），即利用 O(log⁡n)O(\log{n}) 复杂度找到最佳转移位置。

我们可以很容易 通过反证法结合 g 数组的定义来证明 g 数组具有「单调递增」特性。

假设存在某个位置 i 和 j，且 i<ji < j，不满足「单调递增」，即如下两种可能：

  • g[i]=g[j]=xg[i] = g[j] = x：这意味着某个值 x 既能作为长度 i 的上升子序列的最后一位，也能作为长度为 j 的上升子序列的最后一位。 根据我们对 g 数组的定义，g[i]=xg[i] = x 意味在所有长度为 i 上升子序列中「最小结尾元素」为 x，但同时由于 g[j]=xg[j] = x，而且「上升子序列」必然是「严格单调」，因此我们可以通过删除长度为 j 的子序列后面的元素（调整出一个长度为 i 的子序列）来找到一个比 g[i]g[i] 小的合法值。 也就是我们找到了一个长度为 i 的上升子序列，且最后一位元素必然严格小于 x。因此 g[i]=g[j]=xg[i] = g[j] = x 恒不成立；

  • g[i]>g[j]=xg[i] > g[j] = x：同理，如果存在一个长度为 j 的合法上升子序列的「最小结尾元素」为 x 的话，那么必然能够找到一个比 x 小的值来更新 g[i]g[i]。即 g[i]>g[j]g[i] > g[j] 恒不成立。

根据全序关系，在证明 g[i]=g[j]g[i] = g[j] 和 g[i]>g[j]g[i] > g[j] 恒不成立后，可得 g[i]<g[j]g[i] < g[j] 恒成立。

至此，我们证明了 g 数组具有单调性，从而证明了每一个 f[i]f[i] 均与朴素 LIS 解法得到的值相同，即贪心解是正确的。

动态规划 + 贪心 + 二分

根据「基本分析 & 证明」，通过维护一个贪心数组 g，来更新动规数组 f，在求得「最长上升子序列」长度之后，利用「“公共子序列”和“上升子序列”」的一一对应关系，可以得出“最长公共子序列”长度，从而求解出答案。

Java 代码：

class Solution {
    public int minOperations(int[] t, int[] arr) {
        int n = t.length, m = arr.length;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.put(t[i], i);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            int x = arr[i];
            if (map.containsKey(x)) list.add(map.get(x));
        }
        int len = list.size();
        int[] f = new int[len], g = new int[len + 1];
        Arrays.fill(g, Integer.MAX_VALUE);
        int max = 0;
        for (int i = 0; i < len; i++) {
            int l = 0, r = len;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (g[mid] < list.get(i)) l = mid;
                else r = mid - 1;
            }
            int clen = r + 1;
            f[i] = clen;
            g[clen] = Math.min(g[clen], list.get(i));
            max = Math.max(max, clen);
        }
        return n - max;
    }
}

C++ 代码：

class Solution {
public:
    int minOperations(vector<int>& t, vector<int>& arr) {
        int n = t.size(), m = arr.size();
        map<int, int> map;
        for (int i = 0; i < n; ++i) {
            map[t[i]] = i;
        }
        vector<int> list;
        for (int i = 0; i < m; ++i) {
            int x = arr[i];
            if (map.count(x)) list.push_back(map[x]);
        }
        int len = list.size();
        vector<int> f(len), g(len + 1, numeric_limits<int>::max());
        int maxVal = 0;
        for (int i = 0; i < len; ++i) {
            int l = 0, r = len;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (g[mid] < list[i]) l = mid;
                else r = mid - 1;
            }
            int clen = r + 1;
            f[i] = clen;
            g[clen] = min(g[clen], list[i]);
            maxVal = max(maxVal, clen);
        }
        return n - maxVal;
    }
};

Python 代码：

class Solution {
public:
    int minOperations(vector<int>& t, vector<int>& arr) {
        int n = t.size(), m = arr.size();
        map<int, int> map;
        for (int i = 0; i < n; ++i) {
            map[t[i]] = i;
        }
        vector<int> list;
        for (int i = 0; i < m; ++i) {
            int x = arr[i];
            if (map.count(x)) list.push_back(map[x]);
        }
        int len = list.size();
        vector<int> f(len), g(len + 1, numeric_limits<int>::max());
        int maxv = 0;
        for (int i = 0; i < len; ++i) {
            int l = 0, r = len;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (g[mid] < list[i]) l = mid;
                else r = mid - 1;
            }
            int clen = r + 1;
            f[i] = clen;
            g[clen] = min(g[clen], list[i]);
            maxv = max(maxv, clen);
        }
        return n - maxv;
    }
};

TypeScript 代码：

class Solution:
    def minOperations(self, t: List[int], arr: List[int]) -> int:
        n, m = len(t), len(arr)
        map_ = {t[i]: i for i in range(n)}
        list_ = [map_[x] for x in arr if x in map_]
        sz = len(list_)
        f, g = [0] * sz, [float('inf')] * (sz + 1)        
        maxv = 0
        for i in range(sz):
            l, r = 0, sz
            while l < r:
                mid = l + r + 1 >> 1
                if g[mid] < list_[i]:
                    l = mid
                else:
                    r = mid - 1
            clen = r + 1
            f[i] = clen
            g[clen] = min(g[clen], list_[i])
            maxv = max(maxv, clen)
        return n - maxv
  • 时间复杂度：通过 O(n)O(n) 复杂度得到 targettarget 的下标映射关系；通过 O(m)O(m) 复杂度得到映射数组 listlist；贪心求解 LIS 的复杂度为 O(mlog⁡m)O(m\log{m})。整体复杂度为 O(n+mlog⁡m)O(n + m\log{m})
  • 空间复杂度：O(n+m)O(n + m)
avatar
文章
阅读
粉丝