代码随想录|四数相加Ⅱ|赎金信|三数之和|四数之和

454. 四数之和

文档讲解：代码随想录
视频讲解：B站视频(https://www.bilibili.com/video/BV1Md4y1Q7Yh)
状态：看过B站视频后AC，需要日后复习。

这道题需要从四个数组中各取一个元素相加和为零，并且需要返回有多少种可以四数相加为0的方案。这个问题适合使用哈希表解决，而与三数之和以及四数之和不同，前两个问题需要考虑方案的去重，也就是数组索引可能不同，但是索引所对应的值相同。而此问题采用四个数组，即使值相同，只要索引不完全相同就不视为同一个解答，并且这道题不需要返回索引。因此不需要去重，适合使用hash表解决。

此问题中，hash表的key保存两个数组的元素之和，value保存相加得到该值的组合个数

具体的解决方法如下：

• 使用两层for循环遍历前两个数组，记录两个数组所有的可能之和
• 若hash表中不存在这个和，则记录并将value设为1，否则将value+1
• 再使用两层for循环遍历后两个数组，记录两个数组所有的可能之和
• 检测该和是否存在于hash表中，若存在，则将value加到全局计数器中。

时间复杂度为 , 具体代码如下：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> hash1 = new HashMap<>();
        int counter = 0;
        for (int i : nums1) {
            for (int j : nums2) {
                int firstsum = i + j;
                hash1.put(firstsum, hash1.getOrDefault(firstsum, 0) + 1);
            }
        }
        for (int i : nums3) {
            for (int j : nums4) {
               counter += hash1.getOrDefault(0 - i - j, 0);
            }
        }
        return counter;
    }
}

383. 赎金信

文档讲解：代码随想录
状态：较为简单

这道题需要判断第一个字符串能不能由第二个字符串里的字符组成，并且每个字符只能使用一次，使用HashMap或者自建数组模拟hash操作都可以，key保存字符，value保存字符的出现次数。具体代码思路如下：

• 遍历第二个字符串，将其中的所有字符记录到key中，出现次数记录到value中
• 遍历第一个字符串，查询字符是否在HashMap中出现，若无，返回false，若有，value - 1，若value为0则从HashMap中移除这个元素。

代码如下：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character, Integer> hash = new HashMap<>();
        for (int i = 0; i < magazine.length(); i++) {
            hash.put(magazine.charAt(i), 
                hash.getOrDefault(magazine.charAt(i), 0) + 1);
        }

        for (int i = 0; i < ransomNote.length(); i++) {
            char ch = ransomNote.charAt(i);
            if (hash.containsKey(ch) && hash.get(ch) > 1) {
                hash.put(ch, hash.get(ch) - 1);
            }
            else if (hash.containsKey(ch) && hash.get(ch) == 1) {
                hash.remove(ch);
            }
            else return false;
        }
        return true;
    }
}

15. 三数之和

文档讲解：代码随想录
视频讲解：B站视频
状态：看过视频后自己尝试写出来了，但是需要复习，并且这道题需要日后和四数相加做一个对比。

这道题需要找出同一个数组内三个不同位置的数字相加为零的数，并返回这包含这三个数的三元组，同时不能有重复的三元组。

这道题不适合使用Hash表解决，在去重的时候会比较麻烦，下面给出双指针的解法。日后再补上hash方法

使用双指针的思路如下：

• 首先对数组进行排序
• 定义一个左边界i，在左边界到数组某位之间的闭区间内，双指针从这个闭区间的左右两端开始移动
• 使用左边界进行一轮数组遍历，在每一次迭代的过程中，根据三数之和决定双指针的移动方法
• 去重操作需要在迭代之初以及双指针找到和为0的值时检测。
• 在迭代之初，需要检测当前i索引指向的元素是否与上一次迭代元素相同，若相同，则跳过本次迭代
• 在双指针找到目标元素后，需要将两个双指针指向的下一个元素与当前元素进行对比，若相同则跳过下一个元素。

具体代码如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

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 - 2; i++) {
            if (nums[i] > 0) return result; //若最小的元素都大于零，则停止搜寻,剪枝
            if(i > 0 && nums[i] == nums[i-1]) continue; // 完成对i的去重
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum < 0) left ++;
                else if (sum > 0) right --;
                else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 若将要搜索的下一个元素和当前已找到的这个三元组中有一个元素相同则跳过，直到找到不重复的元素再进入下一个循环
                    while (left < right && nums[right] == nums[right-1]) right --;
                    while (left < right && nums[left] == nums[left+1]) left ++;
                    left ++;
                    right --;
                }
            }
        }
        return result;
    }
}

18. 四数之和

文档讲解：代码随想录
视频讲解：B站视频
状态：在看过视频后AC，总体思路与三数之和相同

思路与三数之和类似，需要两层循环解决这个问题，只是在去重部分稍加修改。由于四数之和要求为指定的一个数，因此在去重判断时需要注意target为负数的情况。具体代码如下:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int k = 0; k < nums.length - 3; k++) {
            if (nums[k] > target && nums[k] > 0) return result; // 剪枝
            if (k > 0 && nums[k] == nums[k - 1]) continue; // 去重
            // System.out.println("k=" + k);
            for (int i = k + 1; i < nums.length - 2; i++) {
                int fir = nums[k] + nums[i];
                if (fir > target && fir > 0) break; //剪枝, 注意，这里为break
                if (i - 1 > k && nums[i] == nums[i-1]) continue;
                // System.out.println("i=" + i);
                int left = i + 1;
                int right = nums.length - 1;
                while (left < right) {
                    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
                    if (sum > target) right -- ;
                    else if (sum < target) left ++;
                    else {
                        // System.out.println("left=" + left + "\nright=" + right);
                        result.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left+1]) left++;
                        while (left < right && nums[right] == nums[right-1]) right--;
                        left++; right--;
                    }
                }
            }
        }
        return result;
    }
}