代码随想录day7|哈希表第二天

454.四数相加②

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[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

思路

这题没有想出来，因为一开始没想到和哈希表会有关联，一直想的是它完成这个过程需要n的四次方，是一个很大的数字。

我们可以利用Map来解决这个问题，首先思路就是我们先算出nums1,nums2的两个数组相加的值为a的以及它为a的频数，并放入Map中，然后因为我们需要去找到和a相加为0的b的频数，所以我们遍历nums3,nums4,找到符合0-a的数然后让频数加回去。这就完成了整个题目。

代码 

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

383.赎金信

给你两个字符串：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

思路

这个题目很好地利用了哈希的作用，如果我们在遍历一个表的时候我们可以在另一个表里面来寻找有没有对应的元素，并且看它的个数是否为0，这里用的哈希表是数组，可以用一个长度为26的数组来统计两个数组每个字母出现的频数。

先统计magizine里面的字母的频数，我们的randamNode是从magazine里面取字母，此时这个数组的频度可以-1，直到整个randomNode遍历完毕，我们看看数组里面是否有为负值，有负值说明是magazine中不存在这个字母了。

代码

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length()>magazine.length()){
            return false;
        }
        int[] alph = new int[26];
        for(char c:magazine.toCharArray()){
            alph[c-'a']++;
        }
        for(char c:ransomNote.toCharArray()){
            alph[c-'a']--;
        }

        for(int i:alph){
            if(i<0)
                return false;
        }
        return true;
    }
}

15.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路

我一开始是没想到这个思路的，这个是参考答案上的思路，我把它做成图画版，这样更直观。

一开始需要进行数组的排序，快排的时间复杂度是0（nlog2n）

一开始先构造i，left，right，三个指针，在i进行循环，循环到最末尾的时候为结束，left和right可以在i的下一位到数组最后都在移动，直到两个指针指向同一个元素为结束

我们把三个指针值相等的元素相加，如果这个相加的和sum是大于target的，我们需要移动右边的right向左移，这样可以把sum变小

如果是sum<target,就需要把target变大，此时left需要往右移。

此外我们还需要做一些剪枝操作：

• 在i移动的时候有可能会有前一个元素和后一个元素一致的情况
• 在left移动的时候也会有前一个元素和后一个元素一致的情况
• 在right移动的时候也会有前一个元素和后一个元素一致的情况

代码

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;
            }
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            int left = i+1;
            int right=nums.length-1;
            while(left<right){
                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]));
                    while(right>left&&nums[left]==nums[left+1])left++;
                    while(right>left&&nums[right]==nums[right-1])right--;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

18.四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、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]]

思路

四数之和和前面的三数之和很相似，不过在一些点上需要注意：

因为增加了一个指针，剪枝操作也要添加一步

如果i指向的数还是负数的话，是可以把sum变小的，这个时候不能直接退出，除非i指向的数是正数且sum>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++){
            if(nums[i]>0&&nums[i]>target){
                return result;
            }
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            for(int j = i+1;j<nums.length;j++){
                if(j>i+1&&nums[j-1]==nums[j]){
                    continue;
                }
                int left = j+1;
                int right = nums.length-1;
                while(left<right){
                    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]));
                        while(left<right&&nums[left]==nums[left+1])left++;
                        while(left<right&&nums[right]== nums[right-1])right--;
                        left++;
                        right--;
                    }
                }   
            }
            
        }
        return result;
    }
}