454.四数相加II
思路
- 不需要考虑去重的操作
- 跟两数之和的思路一样，将数组A、B相加保存到集合里，再在数组C、D相加遍历时查找是否有target-(A+B)的值
- 还需要保存出现的次数，因为题目中要求是出现多少次，所以要用Map
- 代码用到了map的getOrDefault(key，默认值)方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0;
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//统计两个数组中的元素之和，同时统计出现的次数，放入map
for (int i : nums1) {
for (int j : nums2) {
int sum = i + j;
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
}
//统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
for (int i : nums3) {
for (int j : nums4) {
res += map.getOrDefault(0 - i - j, 0);
}
}
return res;
}
}383. 赎金信
思路
跟前两道题的差不多，都是比较，然后查找，但这道题是字母，用数组就可以
使用toCharArray() 方法将字符串转换为字符数组。
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
// shortcut
if (ransomNote.length() > magazine.length()) {
return false;
}
// 定义一个哈希映射数组
int[] record = new int[26];
// 遍历
for(char c : magazine.toCharArray()){
record[c - 'a'] += 1;
}
for(char c : ransomNote.toCharArray()){
record[c - 'a'] -= 1;
}
// 如果数组中存在负数，说明ransomNote字符串中存在magazine中没有的字符
for(int i : record){
if(i < 0){
return false;
}
}
return true;
}
}15. 三数之和
去重
这道题的重点在于去重，不管什么方法，那是nums[i]==nums[i+1]还是nums[i]==nums[i-1]
| i | left | right |
由图可见，left是nums[i+1] ，结果元组中可以重复，但元组不可重复，所以不是i+1
那为什么是i-1呢？这里去重是i要向前检查是否有收录过的数组
双指针解法
- 去重
- 排序
- 双指针(滑动窗口)
让三个数相加等于某个固定值有两种办法
- 一个就是先确定前两个数，查找第三个数，每个数都是需要遍历去查找的，这也是哈希法的思路
- 另一个是排序之后，三个数固定在特殊位置(例如a在i=0，b在i=1，c在最后一个)，按照和大于等于0来对b、c进行替换(由于是有序数组，c向左是变大，b向右是变小)，利用这个规律让三者值满足条件
b、c去重
| -1(i) | 0(left) | 0(left+1) | 1 | 1(right-1) | 1(right) |
对应代码while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
这时是nums[right] == nums[right - 1]并且nums[left] == nums[left + 1]，元组重复，继续移动
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
// 找出a + b + c = 0
// a = nums[i], b = nums[left], c = nums[right]
for (int i = 0; i < nums.length; i++) {
// 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
if (nums[i] > 0) {
return result;
}
if (i > 0 && nums[i] == nums[i - 1]) { // 去重a
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 {
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
return result;
}
}运行时间为27ms，速度又快又好理解
哈希解法
这道题的重点if语句都是反向的，即满足if条件但不满足题意，注意一下
- 虽然与双指针题目不同，排序的作用不是特别大，但还是排序进行优化，例如可以直接判断该数组是否满足题意
- 在哈希表内的去重就是如果nums[i]==nums[n-i]，那么就应该跳过
- 哈希的整体思路跟前几道题一样，都是利用差值来找符合要求的元素
- a,b,c的去重不一样：a是在最外层循环开始时避免了在相同的nums[i]上找b和c b是在内层循环检查避免与前两个元素相等，避免了重复查找
- 而当导出ArrayList时，返回的是满足条件的nums[i]和nums[j]，和c，c是确定存在set中的值，但要remove(c)--c的去重，为了避免添加相同的元组
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
// 如果第一个元素大于零，不可能凑成三元组
if (nums[i] > 0) {
return result;
}
// 三元组元素a去重
//是为了避免在 j 刚好等于 i + 1 或 i + 2 时误判为重复，因为首次进入循环时 nums[j] 可能与 nums[i] 相同或紧接着的下一个值相同，这是允许的。
//i>0是为了保证i-1有效
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
HashSet<Integer> set = new HashSet<>();
for (int j = i + 1; j < nums.length; j++) {
// 三元组元素b去重
if (j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]) {
continue;
}
int c = -nums[i] - nums[j];
if (set.contains(c)) {
result.add(Arrays.asList(nums[i], nums[j], c));
set.remove(c); // 三元组元素c去重
} else {
set.add(nums[j]);
}
}
}
return result;
}
}执行时间364ms，真是费时又费力
18. 四数之和
四数之和比三数之和大一个数，在i的后面放一个j来再套一个循环
在内循环中把i和j看成一个数就行
剪枝
- nums[i] > target
- nums[i]+nums[j] > target
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++) {
// nums[i] > target 直接返回, 剪枝操作
if (nums[i] > 0 && nums[i] > target) {
return result;
}
if (i > 0 && nums[i - 1] == nums[i]) { // 对nums[i]去重
continue;
}
for (int j = i + 1; j < nums.length; j++) {
// nums[i]+nums[j] > target 直接返回, 剪枝操作
if (nums[i]+nums[j] > 0 && nums[i]+nums[j] > target) {
break;
}
if (j > i + 1 && nums[j - 1] == nums[j]) { // 对nums[j]去重
continue;
}
int left = j + 1;
int right = nums.length - 1;
while (right > left) {
// nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
long sum = (long) 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]));
// 对nums[left]和nums[right]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
left++;
right--;
}
}
}
}
return result;
}
}
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
