目录
454.四数相加II
建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间 换时间， 工业开发也是这样。
题目链接/文章讲解/视频讲解：代码随想录
题解思路：
使用哈希表的数据结构中的map集合解决问题，大体思路是：先用两层for循环计算数组1和数组2之间的元素之和，并将其结果出现的次数存放在map集合中一一对应的键值对中，其中用key键保存结果，用value保存结果出现的次数，再使用两层for循环计算数组3和数组4之间的元素之和，然后用0减去这两个元素之和判断是否在 存放在map集合的key键中 的结果出现过，最后去计算符合满足四数相加为0四元组的次数。
在题解本题时，需要注意以下几点：
第一：先用两层for循环计算数组1和数组2之间的元素之和，再使用两层for循环计算数组3和数组4之间的元素之和，然后用0减去这两个元素之和判断是否在 存放在map集合的key键中 的结果出现过，此时的时间复杂度为n^2，比先三层for循环计算其中三个数组之间元素之和，再用剩余的数组去判断，其时间复杂度为n^3，要快很对！！！
第一：需要用map去存储计算数组1和数组2两两元素之和的结果和结果出现的次数，很显然这是一一对应的关系，不能用存储单列集合的collection接口中set集合去存储双列数据
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
HashMap<Integer, Integer> map = new HashMap<>(); //用来存储nums1、nums2数组中元素相加之和
int count = 0; //记录有多少个满足的四元组
//先对nums1、nums2数组中两两元素相加，将其值存放在map的key键中，相加的结果出现的次数放在map的value值中
for(int i = 0; i < nums1.length; i++){
for(int j = 0; j < nums1.length; j++){
int temp = nums1[i] + nums2[j];
if(map.containsKey(temp)){
map.put(temp, map.get(temp) + 1); //如果在key键中出现过之前计算的结果，那么将此value值进行+1操作
}else{
map.put(temp, 1); //如果存储key键的set集合中没出现过该结果，那么直接将value值赋值为1操作即可
}
}
}
//再求nums3、nums4数组中的两两元素相加，再用0减去相加之和得到的目标值判断存放在map的key键中是否出现过，如果出现那就累加count值即可，但此时累加看的一定是map集合中value值！！！
for(int element3 : nums3){
for(int element4 : nums4){
int target = 0 - (element3 + element4);
if(map.containsKey(target)){
count += map.get(target); //执行到此行代码说明存在在map中的key键出现了目标值，那就累加count值即可，但此时累加看的一定是map集合中value值
}
}
}
return count;
}
}383. 赎金信
建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题
题目链接/文章讲解：代码随想录
题解思路：
本题和 242.有效的字母异位词 是一个思路 ，算是拓展题，都是把数组当作哈希表去使用，由于都是小写字母，那么只需要定义一个大小为26的数组即可，然后通过magazine.charAt(i) - 'a'（ransomNote也类似）来计算每个字母对应位置元素值进行累加操作（对于ransomNote就是累减操作），就可以判断magazine是否包含ransomNote中所有的字符，这里判断的时候一定是count[ransomNote.charAt(i) - 'a'] < 0小于进行判断，不能使用!=来判断，注释有详细说明：因为如果magazine中有3个a，而ransomNote中只需要两个a，那么就会判断错误，其实只要遍历ransomNote中字符串所计算出的位置处的元素值小于0，就能说明ransomNote字符串总存在magazine中没有的字符
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
int[] count = new int[26];
//把数组当作哈希表去使用
for(int i = 0; i < magazine.length(); i++){
count[magazine.charAt(i) - 'a']++;
}
for(int i= 0; i < ransomNote.length(); i++){
count[ransomNote.charAt(i) - 'a']--;
}
for(int i = 0; i < ransomNote.length(); i++){
if(count[ransomNote.charAt(i) - 'a'] < 0){ //注意这里判断magazine是否包含ransomNote中的所有字符串时，不能以 != 符号去判断，因为如果magazine中有3个a，而ransomNote中只需要两个a，那么就会判断错误，其实只要遍历ransomNote中字符串所计算出的位置处的元素值小于0，就能说明ransomNote字符串总存在magazine中没有的字符
return false;
}
}
return true;
}
}15. 三数之和（二刷对给定的数组直接处理）
建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。
题目链接/文章讲解/视频讲解：代码随想录
本体给的代码和代码中的注释是没问题的，我只不过用list集合存储数组元素处理，一开始想的是好调用collections工具类中的sort()方法对数组中的元素进行排序，但是才发现arrays工具类也可以直接对数组进行排序！！！二刷可以改成用直接对给定的数组进行直接处理，不需要用集合存储数组中的元素，再对集合中的元素进行排序。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> resultList = new ArrayList<>();
//将给定的数组元素存放在collection接口的list集合中，好方便直接调用其Collections.sort(list)方法对数组中的元素进行排序
List<Integer> numsList = new ArrayList<>();
for(int element : nums){
numsList.add(element);
}
Collections.sort(numsList); //对存放在numsList集合中的元素按照升序排序，后面直接对numsList集合中的元素操作即可
//情景限定描述：a+b+c
for(int i = 0; i < numsList.size(); i++){ //对a进行遍历
if(numsList.get(i) > 0){ //排序后的集合如果第一个元素大于0，那么不可能找到三个数相加为0的数组
return resultList;
}
if(i > 0 && numsList.get(i) == numsList.get(i - 1)){ //获取到a的值后，就需要对a进行去重操作，这里去重指的不是对三元组里面相同的元素值进行去重，而是判断说是否出现过相同三元组的元素之和为0，这里就需要
continue; //对a的值进行去重，这里一定是判断i与i - 1的位置是否相同，因为我们是将i + 1的处的元素定义为b的值，如果判断 i 与 i+1 处的元素是否相同，那么就表示如果三元组内有相同元素就给pass掉了，这显然是不符合题意的
}
int left = i + 1; //a所在位置固定好后，再去移动b和c所在的位置，这里b的位置使用left来表示索引的位置，c的位置使用right来表示索引的位置
int right = numsList.size() - 1;
while(right > left){
long sum = (long)numsList.get(i) + numsList.get(left) + numsList.get(right);
if(sum > 0){
right--;
}else if(sum < 0){
left++;
}else{
List<Integer> result = new ArrayList<>(Arrays.asList(numsList.get(i), numsList.get(left), numsList.get(right)));
resultList.add(result); //执行到这个方法体就说明已经获取到了b和c的值了，现在就需要考虑去重的操作了
while(right > left && (numsList.get(left) == numsList.get(left + 1))){ //对b进行去重操作
left++; //对b进行去重操作判断的一定是left 与 left + 1处的元素值是否相同，同理，如果判断 left 与 left-1 处的元素是否相同，因为我们是将left - 1的处的元素定义为a值，此时就表示如果三元组内有相同元素就给pass掉了，这显然是不符合题意的
}
while(right > left && (numsList.get(right) == numsList.get(right - 1))){//对c的值进行去重操作
right--; //对c进行去重操作判断的显然是判断 right 与 right+1 处的元素是否相同，因为初始化时right的位置已经到达数组尾部了
}
right--;
left++;
}
//这里去重是通过比较相邻两个元素值是否相同来判断是不是重复的三元组，因为如果获取到了a值后，也获取到了b和c值，那么a元素前一个位置元素值a'一致，那么肯定也会搭配b和c值满足三个元素之和为0，此时[a,b,c]和[a',b,c]就是重复的三元组元素了，这就不符合题意了
//对c和d的去重是紧跟着获取到c和d之后去重
}
}
return resultList;
}
}18. 四数之和
建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。
题目链接/文章讲解/视频讲解：代码随想录
题解思路：
写列出解决本题最最重要的一步：对数组nums进行排序，后面所有的剪枝和双指针的移动移动都是基于排序后的数组进行思路分析的！！！！！！！！！总结出本题的三个要素：
第一要素：对于前两个元素的获取需要进行剪枝操作，以便快速判断是否能够获取满足条件的四元组，而不必都要进行循环判断，太耗费时间了，具体的剪枝操作和判断条件注释详细说明过；
第二要素：对于获取到每个元素之后，都要进行去重的操作，使得返回的结果中不能包含相同的四元组，，具体每个元素的去重操作原理和求三树之和原理一致，可以去看三数之和原理的注释；
第三要素：对于获取到的四元组后要进行保存到list集合容器中，其中踩过的坑就是：int类型存储数据会造成越界的错误，有关代码后面有注释，注意观察！！！
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> resultList = new ArrayList<>(); //用来存放多个四元组
//使用双指针的思路去进行求解，所以前提一定是对排序后的数组进行处理的，第一步很重要，是后面所有步骤的基石
Arrays.sort(nums);
//情景限定描述：a+b+c+d
for(int k = 0; k < nums.length; k++){ //获取元素a的值
//对获取到的元素a进行剪枝和去重操作，以下可以进行剪枝操作就是因为对数组进行排序了，才能进行，所有第一步对数组进行排序时是很重要的步骤
if( nums[k] > 0 && target > 0 && nums[k] > target){ //这里剪枝操作一定要添加了这两个前提target > 0，nums[k] > 0，因为此时target是任意指定的数，如果target是负数-5，而此时nums[k] = -4，那么只判断nums[k] > target显然是错误的，因为后面的元素也可能是负数，相加之后的和也可能会变小
break;
}
if(k > 0 && nums[k] == nums[k-1]){ //对获取到的a进行去重操作，还是将k和k-1处的元素值进行比较，和三数之和的原理一致
continue;
}
for(int i = k + 1; i < nums.length; i++ ){ //获取元素b的值
if(nums[i] + nums[k] > target && nums[i] > 0 && nums[k] > 0 && target > 0){ //对获取到的元素b进行剪枝操作
break;
}
if(i > k + 1 && nums[i] == nums[i - 1]){ //对获取到的元素b进行去重操作
continue;
}
int left = i + 1;
int right = nums.length - 1;
while(right > left){
long sum = (long) nums[k] + nums[i] + nums[left] + nums[right]; //踩过的坑，int类型存储数据会造成越界的错误
if(sum > target){
right--;
}else if(sum < target){
left++;
}else{
resultList.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right])); //执行到此行代码说明已经获取到了元素c和元素d，紧跟着进行去重操作就，别忘记去重还要对left和right指针分别进行加加和减减操作，因为还需要去判断还能获取另一组元素c和元素d，所有得继续遍历下一个元素
while(right > left && nums[left] == nums[left + 1]){ //对元素c进行去重操作，如果重复直接去遍历下一个元素
left++;
}
while(right > left && nums[right] == nums[right - 1]){ //对元素d进行去重操作，如果重复直接去遍历下一个元素
right--;
}
right--;
left++;
}
}
}
}
return resultList;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
