什么叫神仙公司，裁员赔偿N+7思科最新消息，多位思科（Cisco）大连的蓝牌员工向媒体爆料，在 9 月 19 号正式收

思科

最新消息，多位思科（Cisco）大连的蓝牌员工向媒体爆料，在 9 月 19 号正式收到裁员通知。预计本次裁员涉及 300 人。

蓝牌是指思科正式员工（正编），红牌则是指思科与第三方公司签署合同的非正式员工（外包）。

一位思科蓝牌员工分享道：裁员的消息其实从中秋节前就开始流传了，假期结束回来不久，HR 就开始陆续找人谈话，目前自己所在的组 20 人裁掉了 3 人（占比 15%），本次受影响的员工，主要和日韩项目相关，还有部分负责 TAC（技术售后）的岗位。

思科本次的人员调整，主要是给将来的业务转移（大部分业务将会转移到印度或日本）做准备。

本次思科裁员给出的赔偿方案也很人性化，员工可根据自己情况二选一：

直接走人，赔偿 N+7
延迟两个月，赔偿 N+5

延迟的两个月也是正常发工资，其实两种方案本质都是 N+7。

只不过后者相当于赔偿之余，额外提供环境给员工过渡（找工作），这里的环境是指在职所享有的各项福利，班车、食堂、社保等等。

思科（Cisco）是我们的神仙公司中的常客，出现过两次（北京 & 苏州）。虽然这些神仙公司不总是能够躲过"外企撤退/裁员潮"，但能够确保在职期间的各种福利待遇，真的要裁员的时候，也和员工有商有量，赔偿到位，对我们打工人来说已经很好，何尝对不起"神仙"二字呢。

又是体验别人裁员裁出"拆迁"感觉的一天，思科赔偿 N+7，你怎么看？

...

回归主题。

来一道和 HOT 100 级别的题目。

题目描述

平台：LeetCode

题号：41

给你一个未排序的整数数组 nums，请你找出其中没有出现的最小的正整数。

进阶：你可以实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案吗？

示例 1：

输入：nums = [1,2,0]

输出：3

示例 2：

输入：nums = [3,4,-1,1]

输出：2

示例 3：

输入：nums = [7,8,9,11,12]

输出：1

提示：

$0 <= nums.length <= 300$
$-2^{31} <= nums[i] <= 2^{31} - 1$

桶排序（原地哈希）

令数组长度为 n，那么答案必然在 $[1, n + 1]$ 范围内。

我们可以使用「桶排序」的思路，将每个数放在其应该出现的位置上。

基本思路为：

按照桶排序思路进行预处理：保证 1 出现在 nums[0] 的位置上，2 出现在 nums[1] 的位置上，…，n 出现在 nums[n-1] 的位置上。不在 $[1, n]$ 范围内的数不用动。

例如样例中 [3,4,-1,1] 将会被预处理成 [1,-1,3,4]。
遍历 nums，找到第一个不在应在位置上的 $[1, n]$ 的数。如果没有找到，说明数据连续，答案为 n+1

例如样例预处理后的数组 [1,-1,3,4] 中第一个 nums[i] != i + 1 的是数字 2（i = 1）。

Java 代码：

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            while (nums[i] >= 1 && nums[i] <= n && nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
                swap(nums, i, nums[i] - 1);
            }
        }   
        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) return i + 1;
        }
        return n + 1;
    }
    void swap(int[] nums, int a, int b) {
        int c = nums[a];
        nums[a] = nums[b];
        nums[b] = c;
    }
}

C++ 代码：

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            while (nums[i] >= 1 && nums[i] <= n && nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
                swap(nums[i], nums[nums[i] - 1]);
            }
        }
        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) return i + 1;
        }
        return n + 1;
    }
};

Python 代码：

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(n):
            while 1 <= nums[i] <= n and nums[i] != i + 1 and nums[i] != nums[nums[i] - 1]:
                nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
        for i in range(n):
            if nums[i] != i + 1:
                return i + 1
        return n + 1

TypeScript 代码：

function swap(nums, a, b) {
    const c = nums[a];
    nums[a] = nums[b];
    nums[b] = c;
}
function firstMissingPositive(nums: number[]): number {
    const n: number = nums.length;
    for (let i: number = 0; i < n; i++) {
        while (nums[i] >= 1 && nums[i] <= n && nums[i] != i + 1 && nums[i] != nums[nums[i] - 1]) {
            swap(nums, i, nums[i] - 1);
        }
    }
    for (let i: number = 0; i < n; i++) {
        if (nums[i] != i + 1) return i + 1;
    }
    return n + 1;
};

时间复杂度：每个数字应该被挪动的数都会被一次性移动到目标位置。复杂度为 $O(n)$
空间复杂度： $O(1)$