题目:
给你四个整数数组
nums1、nums2、nums3和nums4，数组长度都是n，请你计算有多少个元组(i, j, k, l)能满足：
0 <= i, j, k, l < nnums1[i] + nums2[j] + nums3[k] + nums4[l] == 0示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2 解释： 两个元组如下： 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0示例 2：
输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0] 输出：1提示：
n == nums1.lengthn == nums2.lengthn == nums3.lengthn == nums4.length1 <= n <= 200-228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228
自己看到题目的第一想法
肯定不能写出o(n^4) 时间复杂度的算法, 不为其他, LeetCode 肯定过不了. 但是有四个数组, 遍历四个数组是少不了的. 可以通过数学推理, 得到神奇的方程式吗? 好像并没有办法, 把两个数组拼接在一起呢, 或者把两个数组先求和, 得到新的解?(这里其实想到解法了, 但是觉得不会那么暴力吧)我在想什么, 头脑好像乱七八糟的... 先看视频再说吧.
看完代码随想录之后的想法
先将两个数组中的数, 两两相加, 结果保存到 Map 中. 再将另外两个数组的数两两相加, 当 Map 中存在相加后结果的负数时, 则把 Map 中的值获取出来, 添加到结果中.
// 第一种写法:
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> sum = new HashMap<>();
int result = 0;
for (int i = 0; i < nums1.length; i++) { // 注意这里不是用 for (int number:nums1) 的写法
for (int j = 0; j < nums2.length; j++) {
// 注意这里的 getOrDefault
sum.put(nums1[i] + nums2[j], sum.getOrDefault(nums1[i] + nums2[j], 0) + 1);
}
}
for (int i = 0; i < nums3.length; i++) {
for (int j = 0; j < nums4.length; j++) {
result += sum.getOrDefault(-nums3[i]-nums4[j], 0);
}
}
return result;
}
}// 第二种写法: 思路上和第一种是一样的, 但是因为用了注意1-5的写法
// LeetCode 反馈的执行时间大大缩短了, 这个让我第一次深刻的感受到
// Java 的 API 是高效的, 并且是需要被个体认真对待和掌握的.
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> sum = new HashMap<>();
int result = 0;
for (int number1 : nums1) { // 注意1
for (int number2 : nums2) {// 注意2
sum.put(number1 + number2, sum.getOrDefault(number1 + number2, 0) + 1);
}
}
for (int number1 : nums3) { // 注意3
for (int number2 : nums4) {// 注意4
result += sum.getOrDefault(-number1-number2, 0);// 注意5 getOrDfault
}
}
return result;
}
}
自己实现过程中遇到哪些困难
1. 明明已经想到了先将两个数组合并, 再合并另外两个数组的思路, 但是觉得难道要写这样 o(n^2) 的代码吗, 于是就放弃了.
2. 实现过程中发现, 将 for(int i = 0; i < arrayObj.length; i++) 修改为 for (Object obj: arrayObj) 后, 效率提高了不少. 让我惊讶于 Java api 的底层优化, 是真的神奇.
题目:
给你两个字符串：
ransomNote和magazine，判断ransomNote能不能由magazine里面的字符构成。如果可以，返回
true；否则返回false。
magazine中的每个字符只能在ransomNote中使用一次。示例 1：
输入：ransomNote = "a", magazine = "b" 输出：false示例 2：
输入：ransomNote = "aa", magazine = "ab" 输出：false示例 3：
输入：ransomNote = "aa", magazine = "aab" 输出：true提示：
1 <= ransomNote.length, magazine.length <= 105ransomNote和magazine由小写英文字母组成
自己看到题目的第一想法
这一题和之前是否是异位单词是一样的, 认真看了一下题目, 找到那句: 单词里只有小写字母. 这样只要 int[] characterCount = new int[26] 记录一下字符出现次数, 之后通过 characterCount 判断字符数量是否满足要求就行.
看完代码随想录之后的想法
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
if (ransomNote.length() > magazine.length()) {
return false;
}
int[] sourceChars = new int[26];
for (char sourceChar : magazine.toCharArray()) {
sourceChars[sourceChar - 'a']++;
}
for (char sourceChar : ransomNote.toCharArray()) {
if (--sourceChars[sourceChar - 'a'] < 0) {
return false;
}
}
return true;
}
}自己实现过程中遇到哪些困难
自信的提交 LeetCode 后发现效率不够. 但是后来重新提交好像就ok了. 以为是自己用 for (int i = 0; i < word.length(); i++) { // word.charAt(i);} 而不是用 for (Char character : word.toCharArray()) {} 导致的, 但是后来试了一下, 两者差距不大. 这个和四数求和里的发现不同. 也许是字符串的优化本身比较好吗? 当发现效率不够高时, 翻回去看了一下文章解释. 其实总是都该认真看看的, 但是今天挺疲惫, 阅读太漂浮了, 所以效率极低.
题目:
给你一个整数数组
nums，判断是否存在三元组[nums[i], nums[j], nums[k]]满足i != j、i != k且j != k，同时还满足nums[i] + nums[j] + nums[k] == 0。请你返回所有和为
0且不重复的三元组。注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。示例 2：
输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 。示例 3：
输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 。提示：
3 <= nums.length <= 3000-105 <= nums[i] <= 105
自己看到题目的第一想法
1. 做过!!!
2. 有点记不起来了, 但是做出来!!!
3. 执行效率怎么那么低呢?
4. 我写的方法好像和暴力破解没什么区别, 变成 o(n^3) 时间复杂度了, 加一个 Map 把最里面的 for 去掉吧. 嗯嗯, 优化了一些. 为什么还是排在倒数 40% 呢?
5. 还是去看题解吧.
// 第一次自己实现的方案, 通过一个 Map 记录了所有数字出现的索引
// 将三数之和, 减为两数之和
// 这个方案比文章里的暴力法时间复杂度上会好一些, 因为额外用了一些空间
// 但是这个效率也不高(72ms左右, 击败了10%... java 用户)
class Solution {
public List<List<Integer>> threeSum(int[] numbers) {
List<List<Integer>> result = new ArrayList<>();
Map<Integer, Integer> numbersIndex = new HashMap<>();
Arrays.sort(numbers);
for (int i = 0; i < numbers.length; i++) {
numbersIndex.put(numbers[i], i);
}
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] > 0) {
break;
}
if (i > 0 && numbers[i] == numbers[i - 1]) {
continue;
}
for (int j = i + 1; j < numbers.length; j++) {
if (numbers[i] + numbers[j] > 0) {
break;
}
if (j > i + 1 && numbers[j] == numbers[j - 1]) {
continue;
}
Integer target = numbersIndex.get(-(numbers[i] + numbers[j]));
if (target != null && target > j) {
result.add(Arrays.asList(numbers[i], numbers[j], -(numbers[i] + numbers[j])));
}
}
}
return result;
}
}看完代码随想录之后的想法
双指针的解法好多了, 效率真高!
// 注意: 这个版本还没有用到双指针, 该版本是低效的.
// 不额外使用空间记录数组中元素的索引
class Solution {
public List<List<Integer>> threeSum(int[] numbers) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(numbers);
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] > 0) {
break;
}
if (i > 0 && numbers[i] == numbers[i - 1]) {
continue;
}
Set<Integer> existsNumber = new HashSet<>();
for (int j = i + 1; j < numbers.length; j++) {
if (j > i + 2 && numbers[j] == numbers[j - 1] && numbers[j - 1] == numbers[j - 2]) {
continue;
}
if (existsNumber.contains(-(numbers[i] + numbers[j]))) {
result.add(Arrays.asList(numbers[i], numbers[j], -(numbers[i] + numbers[j])));
existsNumber.remove(-(numbers[i] + numbers[j]));
} else {
existsNumber.add(numbers[j]);
}
}
}
return result;
}
}// 三数之和, 双指针版本
// 这个版本才排到 70% 还是不够高.
// 今天太困了, 不想去看为什么了T_T
class Solution {
public List<List<Integer>> threeSum(int[] numbers) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(numbers);
int left;
int right;
int sum;
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] > 0) {
break;
}
if (i > 0 && numbers[i] == numbers[i - 1]) {
continue;
}
left = i + 1;
right = numbers.length - 1;
while (left < right) {
sum = numbers[i] + numbers[left] + numbers[right];
if (sum > 0) {
right--;
} else if (sum < 0) {
left++;
} else {
result.add(Arrays.asList(numbers[i], numbers[left], numbers[right]));
while (left < right && numbers[right - 1] == numbers[right]) {
right--;
}
while (left < right && numbers[left + 1] == numbers[left]) {
left++;
}
right--;
left++;
}
}
}
return result;
}
}自己实现过程中遇到哪些困难
1. 磕磕绊绊的完成, 然而效率不高.
2. 去重部分比较麻烦, 剪枝条件总是想不清楚.
题目:
给你一个由
n个整数组成的数组nums，和一个目标值target。请你找出并返回满足下述全部条件且不重复的四元组[nums[a], nums[b], nums[c], nums[d]]（若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < na、b、c和d互不相同nums[a] + nums[b] + nums[c] + nums[d] == target你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0 输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]示例 2：
输入：nums = [2,2,2,2,2], target = 8 输出：[[2,2,2,2]]提示：
1 <= nums.length <= 200-109 <= nums[i] <= 109-109 <= target <= 109
自己看到题目的第一想法
又是一个 o(n^4) 的陷阱. 看到提示说直接看视频, 那就看吧! 毕竟要数组下标, 不能排序了, 那就不能套之前三数和的逻辑. 视频看到开头, 咦, 好像不是返回下标, 返回数字就行了, 那就可以排序, 就可以套三字和的逻辑了. 这个是拓展送分题, 很快的.
然而... 剪枝条件似乎写错了, if (numbers[i] > target) { break; } 为什么会导致结果丢失呢?
于是乖乖的把视频看完, 才想到 负数 加 负数 可以越加越小... 小学数学了吧?
看完代码随想录之后的想法
在三数和的逻辑外面套一层 for 循环, 三数和以及外层的 for 循环的剪枝条件修改一下就可以了.
// 背住了答案, 没有理解到原理
// 下次三刷时, 又如何呢!
// 其实我算是掌握了, 只是那么多解决方法, 下次看到题目, 未必能想到最优解.
// 除非常思常练.
class Solution {
public List<List<Integer>> fourSum(int[] numbers, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(numbers);
int left, right;
long sum;
for (int i = 0; i < numbers.length - 3; i++) {
if (i > 0 && numbers[i] == numbers[i - 1]) {
continue;
}
// 传入的值最大为 10^9, 三个这样的数相加就溢出了. 因此需要转为 long
if ((long)numbers[i] + numbers[i + 1] + numbers[i + 2] + numbers[i + 3] > target) {
break;
}
if ((long)numbers[i] + numbers[numbers.length - 1] + numbers[numbers.length - 2] + numbers[numbers.length - 3] < target) {
continue;// 这里不能是 break. 因为第一个数和最大的三个数相加依旧小于目标值的话, 可以通过增大左侧数字而达到和增大的效果
}
for (int j = i + 1; j < numbers.length - 2; j++) {// 留两个空间给 left 和 right
if (j > i + 1 && numbers[j] == numbers[j - 1]) {
continue;
}
if ((long)numbers[i] + numbers[j] + numbers[j + 1] + numbers[j + 2] > target) {
break;
}
if ((long)numbers[i] + numbers[j] + numbers[numbers.length - 1] + numbers[numbers.length - 2] < target) {
continue;// 需要将 j 右移以增大结果
}
left = j + 1;
right = numbers.length - 1;
while (left < right) {
sum = (long)numbers[i] + numbers[j] + numbers[left] +
numbers[right];
if (sum > target) {
right--;
} else if (sum < target) {
left++;
} else {
result.add(Arrays.asList(numbers[i], numbers[j], numbers[left], numbers[right]));
while (left < right && numbers[right - 1] == numbers[right]) {
right--;
}
while (left < right && numbers[left + 1] == numbers[left]) {
left++;
}
right--;
left++;
}
}
}
}
return result;
}
}自己实现过程中遇到哪些困难
无.(太累了不想思考了)
2339
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
