代码随想录第七天|哈希表

Leetcode 454 四数相加II

题目链接: 四数相加II
自己的思路:一开始没想到，类似于两数之和的思想，记住，一定不要眼高手低，多练多练！！！！！定义一个map，用于存放前两个数组的元素之和及出现的次数，定义一个整数count，用于存放数组个数，然后再遍历后两个数组，在map中寻找负的后两个元素之和，如果寻找到count+map出元素出现的个数。

正确思路:哈希表
代码:

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //类似于两数之和的思想
        //定义一个map用于存AB数组元素之和以及出现的次数
        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];
                if (map.containsKey(sum)) map.put(sum,map.get(sum)+1);
                else map.put(sum,1);
            }
        }

        //在map中寻找负的CD数组元素之和，如果寻找到，把里面元素的次数加到count上
        int count = 0;
        for (int i =0;i<nums3.length;i++){
            for (int j=0;j<nums4.length;j++){
                int sum = -(nums3[i]+nums4[j]);
                if (map.containsKey(sum)) count = count + map.get(sum);
            }
        }
        return count;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n^2)$
空间复杂度：$\mathcal{O}(n)$

Leetcode 383 赎金信

题目链接: 赎金信
自己的思路:有效的字母异位词扩展题。完全一样的思路，一个用于数组的++，一个用于数组的–，又由于都是小写字母，所以数组定义为长度为26。

正确思路:哈希表

代码:

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        //如果长度比另一个小，一定不可以表示
        if (magazine.length()<ransomNote.length()) return false;
        //因为都为小写字母，所以用长度为26的数组表示
        int[] res = new int[26];
        //类似于有效的字母异位词的思路
        for (int i =0;i<magazine.length();i++){
            res[magazine.charAt(i)-'a']++;
        }
        for (int i =0;i<ransomNote.length();i++){
            res[ransomNote.charAt(i)-'a']--;
            if (res[ransomNote.charAt(i)-'a']<0) return false;
        }

        return true;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(m+n)$
空间复杂度：$\mathcal{O}(1)$

Leetcode 15 三数之和

题目链接: 三数之和
自己的思路:自己没想到！！！

正确思路:排序+双指针。因为要寻找几个数的和为0，所以最好将数组进行排序来寻找，方便去重，先将数组排序，默认从小到大，然后固定一个数num[i]，在i+1到nums.length-1范围内寻找另外两个数，而且这里比较重要的是，当nums[i]大于0的时候，直接跳出循环即可，当当前nums[i]的值和前面元素相等时，直接剪枝，执行下一次循环，因为这样可以去重；在进行双指针寻找的时候，也是类似的方法进行去重。

代码:

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        //如果空指针或者数组长度小于3，直接返回空数组
        if (nums.length<3||nums==null) return res;
        //最重要的一点！！！数组排序
        Arrays.sort(nums);
        for (int i =0;i<nums.length;i++){
            //如果nums[i]>0的话，不需要考虑后面的元素相加，直接跳出循环即可
            if (nums[i]>0) break;
            //剪枝，去掉重复的(和前面的数进行比较)
            if (i>0&&nums[i]==nums[i-1]) continue;

            //定义两个指针来寻找适合三个数相加为0的索引
            int left = i+1;
            int right = nums.length-1;
            while(left<right){
                int sum = nums[left]+nums[right]+nums[i];
                if (sum<0){
                    left++;
                }else if (sum>0){
                    right--;
                }else{
                    //将四个数转为List加入到res中
                    res.add(Arrays.asList(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 res;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n^2)$
空间复杂度：$\mathcal{O}(n^2)$

相似题型

Leetcode 18 四数之和

题目链接: 四数之和
自己的思路:和三数之和一样的思路，但是有一点要记住，在判断nums[i]>target的时候进行剪枝的时候，一定要加入nums[i]>0，因为nums里面有负数，有可能越加越小，其他的和三数之和基本一模一样。

正确思路:

代码:

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList();
        //如果空指针或者数组长度小于3，直接返回空数组
        if (nums==null||nums.length<4) return res;
        Arrays.sort(nums);
        for (int i =0;i<nums.length;i++){
            //如果nums[i]>0而且nums[i]>target的话，不需要考虑后面的元素相加，直接跳出循环即可
            //一定要有nums[i]>0的条件，因为nums[i]如果为负的话，越加越小
            if (nums[i] > 0 && nums[i]>target) break;

            //剪枝，去重
            if (i>0&&nums[i]==nums[i-1]) continue;  

            for (int j = i+1;j<nums.length;j++){
                //剪枝，去重
                if (j>i+1&&nums[j]==nums[j-1]) continue;
                //定义两个指针需要满足四个数相加为target的数
                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){
                        res.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--;
                    }else if (sum<target){
                        left++;
                    }else if (sum>target){
                        right--;
                    }
                }
            }
        }
        return res;
    }
}

复杂度分析：
时间复杂度：$\mathcal{O}(n^2)$
空间复杂度：$\mathcal{O}(n^2)$