为什么华为到处招人？ - 文章 - 开发者社区

一网友在网上发文为什么华为到处招人，打开招聘网站全是华为的。

我觉得主要是华为人多，20.7万人，就算每年更替5%-10%就是1-2万人。

招的人很多都是大学生，华为又看重学校，这些新人集中到少数名校，那就显得尤为突出了。

还有就是华为业务发展迅速，项目需求增长，需要更多的技术支持。

同时，华为对人才的要求也比较高，既要人多又要能力强，这就造成了用人部门招聘需求强烈，而合适的人才相对较少，所以HR们会积极寻找符合要求的人才，因此得不断招聘来满足需求，给人一种天天在招人的感觉。

还一种可能是外包为了拿提成，不断的约人。

picture.image

--------------下面是今天的算法题--------------

来看下今天的算法题，这题是LeetCode的第40题：组合总和 II。

问题描述

来源：LeetCode第40题

难度：中等

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。

示例1：

输入 : candidates = [10,1,2,7,6,1,5], target = 8,

输出 :

[

[1,1,6],

[1,2,5],

[1,7],

[2,6]

]

示例2：

输入 : candidates = [2,5,2,1,2], target = 5,

输出 :

[

[1,2,2],

[5]

]

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

问题分析

昨天我们刚讲过和这题类似的一道题《组合总和》，不过昨天那道题数组中是没有重复数字的，而今天这题数组中可能会有重复数字，如果有重复数字就会出现重复的组合，所以解这题的关键点是怎么过滤掉重复的组合，我们画个图看下：

picture.image

选择的过程可以把它看作是一棵树，因为每个数字最多只能选择一次，所以选择完当前数字之后下一步要从它的下一个数字开始。上面图中因为有相同的数字，所以结果出现了重复。只需要把重复的剪掉即可。

在计算之前我们需要先对数组排序，这样重复的数字就会挨着了，当出现重复数字的时候，前面数字构成的子集实际上是包含后面数字构成的所有子集，所以当出现重复数字的时候我们需要把后面数字构成的分支剪掉即可。

JAVA：


              
                
public List<List<Integer>> combinationSum2(int[] candidates, int target) {  
    List<List<Integer>> ans = new ArrayList<>();  
    Arrays.sort(candidates);// 先排序  
    dfs(ans, new ArrayList<>(), candidates, target, 0);  
    return ans;  
}  
  
private void dfs(List<List<Integer>> ans, List<Integer> path,  
                 int[] candidates, int target, int start) {  
    if (target == 0) {  
        ans.add(new ArrayList<>(path));  
        return;  
    }  
    for (int i = start; i < candidates.length; i++) {  
        // 因为是有序的，后面的值越来越大，直接终止。  
        if (target < candidates[i])  
            break;  
        if (i > start && candidates[i] == candidates[i - 1])  
            continue; // 去掉重复的，后面分支就不要选择了  
        path.add(candidates[i]);// 选择  
        dfs(ans, path, candidates, target - candidates[i], i + 1);  
        path.remove(path.size() - 1);// 撤销选择  
    }  
}

C++：


              
                
public:  
    vector<vector<int>> combinationSum2(vector<int> &candidates, int target) {  
        vector<vector<int>> ans;  
        vector<int> path;  
        sort(candidates.begin(), candidates.end());// 先排序  
        dfs(ans, path, candidates, target, 0);  
        return ans;  
    }  
  
    void dfs(vector<vector<int>> &ans, vector<int> &path,  
             vector<int> &candidates, int target, int start) {  
        if (target == 0) {  
            ans.emplace_back(path);  
            return;  
        }  
        for (int i = start; i < candidates.size(); i++) {  
            // 因为是有序的，后面的值越来越大，直接终止。  
            if (target < candidates[i])  
                break;  
            if (i > start && candidates[i] == candidates[i - 1])  
                continue; // 去掉重复的，后面分支就不要选择了  
            path.emplace_back(candidates[i]);// 选择  
            dfs(ans, path, candidates, target - candidates[i], i + 1);  
            path.pop_back();// 撤销选择  
        }  
    }

C：


              
                
int cmp(const void *a, const void *b) {  
    return *(const int *) a - *(const int *) b;  
}  
  
void dfs(int **ans, int *path, int *candidates, int candidatesSize, int target,  
         int start, int *returnSize, int **returnColumnSizes, int pathCount) {  
    if (target == 0) {  
        ans[*returnSize] = (int *) malloc(pathCount * sizeof(int));  
        memcpy(ans[*returnSize], path, pathCount * sizeof(int));  
        (*returnColumnSizes)[*returnSize] = pathCount;  
        (*returnSize)++;  
        return;  
    }  
    for (int i = start; i < candidatesSize; i++) {  
        // 因为是有序的，后面的值越来越大，直接终止。  
        if (target < candidates[i])  
            break;  
        if (i > start && candidates[i] == candidates[i - 1])  
            continue; // 去掉重复的，后面分支就不要选择了  
        path[pathCount++] = candidates[i];// 选择  
        dfs(ans, path, candidates, candidatesSize, target - candidates[i],  
            i + 1, returnSize, returnColumnSizes, pathCount);  
        --pathCount;// 撤销选择  
    }  
}  
  
int **combinationSum2(int *candidates, int candidatesSize, int target,  
                      int *returnSize, int **returnColumnSizes) {  
    // 先进行排序  
    qsort(candidates, candidatesSize, sizeof(int), cmp);  
    int n = 3000;  
    *returnSize = 0;  
    int **ans = malloc(n * sizeof(int *));  
    *returnColumnSizes = malloc(n * sizeof(int));  
    int *path = malloc(n * sizeof(int));  
    dfs(ans, path, candidates, candidatesSize, target, 0, returnSize, returnColumnSizes, 0);  
    return ans;  
}

Python：


              
                
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:  
    def backtrack(num: int, start: int):  
        if num == 0:  
            ans.append(path[:])  
            return  
        for i in range(start, len(candidates)):  
            # 因为是有序的，后面的值越来越大，直接终止。  
            if num < candidates[i]:  
                break  
            if i > start and candidates[i] == candidates[i - 1]:  
                continue  # 去掉重复的，后面分支就不要选择了  
            path.append(candidates[i])  # 选择  
            backtrack(num - candidates[i], i + 1)  
            path.pop()  # 撤销选择  
  
    candidates.sort()  # 先对数组进行排序  
    ans = []  # 需要返回的结果  
    path = []  
    backtrack(target, 0)  
    return ans

picture.image

最后欢迎加入苏三的星球，你将获得：苏三AI项目、商城微服务实战、秒杀系统实战、商城系统实战、秒杀系统实战、代码生成工具、系统设计、性能优化、技术选型、底层原理、Spring源码解读、工作经验分享、痛点问题、面试八股文等多个优质专栏。

还有1V1答疑、修改简历、职业规划、送书活动、技术交流。

picture.image

目前星球已经更新了5200+篇优质内容，还在持续爆肝中.....

星球已经被官方推荐了3次，收到了小伙伴们的一致好评。戳我加入学习，已有1600+小伙伴加入学习。

最后送大家赠送一份10万字的面试宝典：

picture.image

扫描下方二维码加我微信，备注：面试，即可免费获取。

picture.image