去哪儿
昨天(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
提示:
target
不包含任何重复元素。
基本分析
为了方便,我们令 target
长度为 n
,arr
长度为 m
,target
和 arr
的最长公共子序列长度为 max
,不难发现最终答案为 n - max
。
因此从题面来说,这是一道最长公共子序列问题(LCS)。
但朴素求解 LCS 问题复杂度为 ,使用状态定义「
为考虑
a
数组的前 i
个元素和 b
数组的前 j
个元素的最长公共子序列长度为多少」进行求解。
而本题的数据范围为 10^5
,使用朴素求解 LCS 的做法必然超时。
一个很显眼的切入点是 target
数组元素各不相同,当 LCS 问题增加某些条件限制之后,会存在一些很有趣的性质。
其中一个经典的性质就是:当其中一个数组元素各不相同时,最长公共子序列问题(LCS)可以转换为最长上升子序列问题(LIS)进行求解。同时最长上升子序列问题(LIS)存在使用「维护单调序列 + 二分」的贪心解法,复杂度为 。
因此本题可以通过「抽象成 LCS 问题」->「利用 target
数组元素各不相同,转换为 LIS 问题」->「使用 LIS 的贪心解法」,做到 的复杂度。
基本方向确定后,我们证明一下第 2 步和第 3 步的合理性与正确性。
证明
1. 为何其中一个数组元素各不相同,LCS 问题可以转换为 LIS 问题?
本质是利用「当其中一个数组元素各不相同时,这时候每一个“公共子序列”都对应一个不重复元素数组的下标数组“上升子序列”,反之亦然」。
我们可以使用题目给定的两个数组(target
和 arr
)理解上面的话。
由于 target
元素各不相同,那么首先 target
元素和其对应下标,具有唯一的映射关系。
然后我们可以将重点放在两者的公共元素上(忽略非公共元素),每一个“公共子序列”自然对应了一个下标数组“上升子序列”,反之亦然。
注意:下图只画出了两个数组的某个片段,不要错误理解为两数组等长。
如果存在某个“公共子序列”,根据“子序列”的定义,那么对应下标序列必然递增,也就是对应了一个“上升子序列”。
反过来,对于下标数组的某个“上升子序列”,首先意味着元素在 target
出现过,并且出现顺序递增,符合“公共子序列”定义,即对应了一个“公共子序列”。
至此,我们将原问题 LCS 转换为了 LIS 问题。
2. 贪心求解 LIS 问题的正确性证明?
朴素的 LIS 问题求解,我们需要定义一个 数组代表以
对于某个 而言,我们需要往回检查
区间内,所有可以将
接到后面的位置
j
,在所有的 中取最大值更新
。因此朴素的 LIS 问题复杂度是
LIS 的贪心解法则是维护一个额外 g
数组, 代表上升子序列长度为
len
的上升子序列的「最小结尾元素」为 x
。
整理一下,我们总共有两个数组:
f
动规数组:与朴素 LIS 解法的动规数组含义一致。代表以
g
贪心数组:代表上升子序列长度为
len
的上升子序列的「最小结尾元素」为x
。
由于我们计算 时,需要找到满足
,同时取得最大
的位置
j
。
我们期望通过 g
数组代替线性遍历。
显然,如果 g
数组具有「单调递增」特性的话,我们可以通过「二分」找到符合 分割点
idx
(下标最大),即利用
我们可以很容易 通过反证法结合 g
数组的定义来证明 g
数组具有「单调递增」特性。
假设存在某个位置 i
和 j
,且 ,不满足「单调递增」,即如下两种可能:
:这意味着某个值
x
既能作为长度i
的上升子序列的最后一位,也能作为长度为j
的上升子序列的最后一位。根据我们对g
数组的定义,意味在所有长度为
i
上升子序列中「最小结尾元素」为x
,但同时由于,而且「上升子序列」必然是「严格单调」,因此我们可以通过删除长度为
j
的子序列后面的元素(调整出一个长度为i
的子序列)来找到一个比小的合法值。也就是我们找到了一个长度为
i
的上升子序列,且最后一位元素必然严格小于x
。因此:同理,如果存在一个长度为
j
的合法上升子序列的「最小结尾元素」为x
的话,那么必然能够找到一个比x
小的值来更新。即
根据全序关系,在证明 和
恒不成立后,可得
至此,我们证明了 g
数组具有单调性,从而证明了每一个
动态规划 + 贪心 + 二分
根据「基本分析 & 证明」,通过维护一个贪心数组 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
- 时间复杂度:通过
复杂度得到
的下标映射关系;通过
复杂度得到映射数组
;贪心求解 LIS 的复杂度为
。整体复杂度为
- 空间复杂度: