代码随想录算法训练营--打卡day6
一.四数相加
1.题目链接
454. 四数相加 II - 力扣（LeetCode）
2.思路
使用
HashSet无法记录每种和出现的次数，当不同的(nums1[i], nums2[j])组合得到相同的和时，会出现统计错误。这里应该使用HashMap来记录和以及其出现的次数
3.代码
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer,Integer>map=new HashMap<>();
for(int i=0;i<nums1.length;i++){
for(int j=0;j<nums2.length;j++){
int sum=nums1[i]+nums2[j];
map.put(sum,map.getOrDefault(sum,0)+1);
}
}
int res=0;
for(int i=0;i<nums3.length;i++){
for(int j=0;j<nums4.length;j++){
int target=0-(nums3[i]+nums4[j]);
if(map.containsKey(target)){
res=res+map.get(target);
}
}
}
return res;
}
}二.题目链接
1.题目链接
383. 赎金信 - 力扣（LeetCode）
2.代码
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
int[]array=new int[26];
for(char ch:magazine.toCharArray()){
array[ch-'a']++;
}
for(char ch:ransomNote.toCharArray()){
array[ch-'a']--;
}
for(int num:array){
if(num<0){
return false;
}
}
return true;
}
}三. 三数之和
1.题目链接
15. 三数之和 - 力扣（LeetCode）
2.思路
- 排序：先对数组进行排序，这样方便后续使用双指针法，并且便于去重操作。
- 遍历数组：从第一个元素开始遍历，将当前元素作为三元组中的第一个元素
a。- 双指针法：在当前元素之后的部分使用双指针
left和right分别指向剩余元素的首尾，计算三数之和sum。
- 若
sum大于 0，说明right指向的元素过大，将right左移。- 若
sum小于 0，说明left指向的元素过小，将left右移。- 若
sum等于 0，找到一个满足条件的三元组，添加到结果列表中，并对left和right进行去重操作。- 去重：在找到满足条件的三元组后，对
left和right进行去重，避免结果中出现重复的三元组。同时，在遍历数组时，对第一个元素a也进行去重。
3.代码
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
/ 对数组进行排序
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
/ 如果当前数大于 0，由于数组有序，后续数都大于 0，不可能找到三数之和为 0 的组合
if (nums[i] > 0) return res;
/ 去重，避免结果中出现重复的三元组
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (right > left) {
int sum = nums[i] + nums[left] + nums[right];
if (sum > 0) {
right--;
} else if (sum < 0) {
left++;
} else {
/ 找到满足条件的三元组
res.add(Arrays.asList(nums[i], nums[left], nums[right]));
/ 对 left 去重
while (right > left && nums[left] == nums[left + 1]) {
left++;
}
/ 对 right 去重
while (right > left && nums[right] == nums[right - 1]) {
right--;
}
/ 移动指针继续寻找其他可能的组合
left++;
right--;
}
}
}
return res;
}
}四. 四数之和
1.题目链接
18. 四数之和 - 力扣（LeetCode）
2.思路
1. 排序操作
Arrays.sort(nums); // 排序数组排序操作是后续双指针法和去重操作的基础。排序后相同元素会相邻，方便去重，而且能利用双指针高效地寻找满足条件的组合。
2. 外层循环（固定第一个数）
for (int k = 0; k < nums.length; k++) { // 剪枝处理 if (nums[k] > target && nums[k] >= 0) { break; // 此处的break可以等价于return result; } // 对nums[k]去重 if (k > 0 && nums[k] == nums[k - 1]) { continue; } // ... }
- 剪枝处理：当
nums[k] > target且nums[k] >= 0时，由于数组有序，后续元素只会更大，不可能再找到满足条件的四元组，所以可以提前结束循环。- 去重操作：若当前元素和前一个元素相同，跳过当前元素，避免结果中出现重复的四元组。
3. 内层循环（固定第二个数）
for (int i = k + 1; i < nums.length; i++) { // 第二级剪枝 if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) { break; // 注意是break到上一级for循环，如果直接return result;会有遗漏 } // 对nums[i]去重 if (i > k + 1 && nums[i] == nums[i - 1]) { continue; } // ... }
- 第二级剪枝：当
nums[k] + nums[i] > target且nums[k] + nums[i] >= 0时，同样由于数组有序，后续元素相加会更大，无法得到满足条件的四元组，所以提前结束当前内层循环。- 去重操作：避免结果中出现重复的四元组。
4. 双指针法（寻找第三个数和第四个数）
int left = i + 1; int right = nums.length - 1; while (right > left) { long sum = (long) nums[k] + nums[i] + nums[left] + nums[right]; if (sum > target) { right--; } else if (sum < target) { left++; } else { result.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right])); // 对nums[left]和nums[right]去重 while (right > left && nums[right] == nums[right - 1]) right--; while (right > left && nums[left] == nums[left + 1]) left++; right--; left++; } }
- 类型转换：为了防止四个整数相加时出现溢出，将和的类型转换为
long。- 双指针移动：若和大于目标值，右指针左移；若和小于目标值，左指针右移；若和等于目标值，将四元组添加到结果集，并对左右指针进行去重操作，然后移动指针继续寻找其他可能的组合。
3.代码
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>>result=new ArrayList<>();
Arrays.sort(nums);
for(int i=0;i<nums.length;i++){
if(nums[i]>target&&nums[i]>=0){
return result;
}
if(i>0&&nums[i]==nums[i-1]){
continue;
}
for(int j=i+1;j<nums.length;j++){
if(nums[i]+nums[j]>target&&nums[i]+nums[j]>=0){
break;
}
if(j>i+1&&nums[j]==nums[j-1]){
continue;
}
int left=j+1;
int right=nums.length-1;
while(right>left){
int sum=nums[i]+nums[j]+nums[left]+nums[right];
if(sum>target){
right--;
}else if(sum<target){
left++;
}else{
result.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
while(right>left&&nums[left]==nums[left+1]){
left++;
}
while(right>left&&nums[right]==nums[right-1]){
right--;
}
left++;
right--;
}
}
}
}
return result;
}
}