在找工作的时候简历就相当于你的门面，那简历花了还能找到工作吗？一网友也是非常困扰：「简历花了，回不去大厂了」简单说一下什么叫做「简历花了」，就是你换工作比较频繁，缺乏稳定性，所以很多公司看都不看这种简历。
那么热心肠的网友是怎么看待「简历花了」呢，有网友就说了：「有多花.我6年9家」不是，哥们，你临时工啊。
还有网友不屑：「为什么有简历花了这种说法？爱咋样咋样，谁也不是一帆风顺踩坑踩雷很正常。」说的好，但没啥用。
更有网友一针见血：「还是因为人太多了惯的」真相了，但大家也无奈啊。
还有网友补伤害：「别慌，到年龄了都差不多。」确实，年龄大了，也是直达垃圾桶。
看完大家的态度，并不是花了，就找不到工作了。但也确确实实有很多公司不会要，所以在你能改变这个世界之前，能不花就不花吧。
那么问题来了，多久跳一次，才不算花了简历呢？参考网友们的意见，至少是2.5年以上，在不影响你规划的前提下，能待久点就待久点。那么大家怎么看呢？
下面是今日的大厂算法题
现在环境就这样，不管是大厂还是小厂，笔面试都会问到算法，所以算法无疑是非常重要的。 下面是今日算法题，来自LeetCode的第47题：全排列 II ，下面是我的算法思路及实现，让我们来看看吧。
# 算法题目
给定一个可能包含重复元素的整数数组，返回该数组所有可能的全排列。
# 算法思路
解决含有重复元素的全排列问题的关键是如何避免生成重复的排列。我们可以采用以下步骤：
排序：首先对数组进行排序，这使得相同的数字都相邻，便于后续步骤中判断重复。
递归和回溯：使 用递归函数生成排列，通过回溯法探索所有可能的排列组合。
使用标记数组：使用一个标记数组来记录哪些数字已经被使用过，从而避免使用相同的数字。
跳过重复的数字：在递归的每一层中，如果当前数字与前一个数字相同，并且前一个数字未被使用过，我们应跳过当前数字以避免重复。
# 代码实现
Java实现
import java.util.*;public classSolution {public List<List<Integer>> permuteUnique(int[] nums) { Arrays.sort(nums); List<List<Integer>> results = new ArrayList<>(); backtrack(results, new ArrayList<>(), nums, new boolean[nums.length]);return results; }privatevoidbacktrack(List<List<Integer>> results, List<Integer> tempList, int[] nums, boolean[] used) {if (tempList.size() == nums.length) { results.add(new ArrayList<>(tempList)); } else {for (int i = 0; i < nums.length; i++) {if (used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1])) continue; tempList.add(nums[i]); used[i] = true; backtrack(results, tempList, nums, used); tempList.remove(tempList.size() - 1); used[i] = false; } } }}
JavaScript实现
functionpermuteUnique(nums) { nums.sort((a, b) => a - b);const results = [];const backtrack = (path, used) => {if (path.length === nums.length) { results.push([...path]);return; }for (let i = 0; i < nums.length; i++) {if (used[i] || (i > 0 && nums[i] === nums[i - 1] && !used[i - 1])) {continue; } path.push(nums[i]); used[i] = true; backtrack(path, used); path.pop(); used[i] = false; } }; backtrack([], Array(nums.length).fill(false));return results;}
Go实现
import"sort"funcpermuteUnique(nums []int) [][]int { sort.Ints(nums)var results [][]intvar backtrack func(path []int, used []bool)backtrack = func(path []int, used []bool) {iflen(path) == len(nums) { result := make([]int, len(path))copy(result, path) results = append(results, result)return }for i := 0; i < len(nums); i++ {if used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1]) {continue } used[i] = true path = append(path, nums[i]) backtrack(path, used) path = path[:len(path)-1] used[i] = false } } backtrack([]int{}, make([]bool, len(nums)))return results}
Python 实现
defpermuteUnique(nums):defbacktrack(path, used):if len(path) == len(nums): results.append(path[:])returnfor i in range(len(nums)):if used[i] or (i > 0and nums[i] == nums[i-1] andnot used[i-1]):continue used[i] = true path.append(nums[i]) backtrack(path, used) path.pop() used[i] = false nums.sort() results = [] backtrack([], [False] * len(nums))return results
# 算法解析
在所有实现中，我们首先对数组进行排序，以简化重复元素的检测。然后，我们通过回溯法探索所有可能的元素组合，同时使用一个布尔数组来跟踪哪些元素已经被使用过。
当我们遇到一个已经使用过的元素或者当前元素与前一个元素相同且前一个元素未被使用时，我们跳过当前元素，从而避免产生重复的排列。
# 示例和测试
python
nums = [1, 1, 2]print(permuteUnique(nums)) # 输出: [[1, 1, 2], [1, 2, 1], [2, 1, 1]]
javascript
console.log(permuteUnique([1, 1, 2])); // 输出: [[1, 1, 2], [1, 2, 1], [2, 1, 1]]
java
System.out.println(new Solution().permuteUnique(newint[]{1, 1, 2}));// 输出: [[1, 1, 2], [1, 2, 1], [2, 1, 1]]
go
fmt.Println(permuteUnique([]int{1, 1, 2})) // 输出: [[1, 1, 2], [1, 2, 1], [2, 1, 1]]
# 总结
通过本文的详细讨论和代码示例，我们可以看到，尽管输入数组可能包含重复元素，我们仍然能够有效地生成所有不重复的全排列。
热门推荐
