Day7|哈希法

刷题

454. 四数相加 II

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

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

• 思路：该题第一思路是使用四重for循环，然后分别计算和，再返回相加为0的次数，时间复杂度为O（n^4），但是该题可以先将两两数组相加，将相加之和存储在哈希表中，然后再对哈希表中数据进行查找，看能不能找到0-target数值，注意map的键使用相加之和，而值使用的是当前两个数组能满足相加和为本值的个数。

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //该处固定从nums1开始加,记录得到某数值的个数
        //两两相加
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                int count=map.getOrDefault(nums1[i]+nums2[j],0)+1;
                map.put(nums1[i]+nums2[j],count);
            }
        }
Map<Integer,Integer> map1=new HashMap<Integer,Integer>();
        for(int i=0;i<nums3.length;i++){
            for(int j=0;j<nums4.length;j++){
                int count=map1.getOrDefault(nums3[i]+nums4[j],0)+1;
                map1.put(nums3[i]+nums4[j],count);
            }
        }
        int sum=0;
          for(Map.Entry<Integer,Integer> m:map.entrySet()){
              int my=m.getKey();
              int num2=m.getValue();
              int num1=map1.getOrDefault(0-my,0);
              sum+=num1*num2;
    
          }
          return sum;
    }

赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

• 注意java在该题中String类型不能使用foreach方法
  该题主要思路就是将magazine的字符提取到一个映射中，主键为字符，值为字符出现的次数，而使用magazine构建ransomNote过程中就是查找ransomNote的字符是否在映射中，并且出现的次数大于等于ransomNote出现的次数。
  代码如下：

public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer> map=new HashMap<>();
        //将magazine中的信息存储到map中
        for(int i=0;i<magazine.length();i++){
            Character item=magazine.charAt(i);
            int count=map.getOrDefault(item,0)+1;
            map.put(item,count);
        }
        for(int i=0;i<ransomNote.length();i++){
            Character item=ransomNote.charAt(i);
            int count=map.getOrDefault(item,0)-1;
            if(count<0)
            return false;
            map.put(item,count);
        }
        return true;
    }

时间复杂度为O(m+n)
由于该题的注释中解释所有的字符均由小写字符组成，那么开辟一个长为26的数组来保存magazine中的信息比使用哈希表效率要更高一些

  public boolean canConstruct(String ransomNote, String magazine) {
        // 定义一个哈希映射数组
        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;
    }

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

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

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

该题思路较难
首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
而一旦等于0，此时收缩left和right的范围，直到left和right相遇为止

public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res=new ArrayList<>();
         Arrays.sort(nums);

         for(int i=0;i<nums.length;i++){
           if(nums[i]>0){
               return res;
           }
           if(i>0){
               if(nums[i]==nums[i-1])
                   continue;
           }
             int left=i+1;
             int right=nums.length-1;
           while(left<right){
               if(nums[i]+nums[left]+nums[right]>0)
                   right--;
               else if(nums[i]+nums[right]+nums[left]==0){
                   List<Integer> list=new ArrayList<>();
                   list.add(nums[i]);
                   list.add(nums[left]);
                   list.add(nums[right]);
                   res.add(list);
                   while(right>left&&nums[right]==nums[right-1])right--;
                   while(right>left&&nums[left]==nums[left+1])left++;
                   right--;
                   left++;

               }else{
                   left++;
               }

           }
         }
        return res;

    }

四数之和
该题通过借鉴三数之和的方式，采取三指针的方式进行解答，首先在一开始剪枝去nums[0]大于0且大于target的这种例子，以免超出int的范围

public static  List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> res=new ArrayList<>();
        if(nums[0]>0&&nums[0]>target)
        return res;
        for(int i=0;i<nums.length-1;i++){
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            for(int left=i+1;left<nums.length-1;left++){
                //在该处进行剪枝
                if(left>i+1&&nums[left]==nums[left-1]){
                    continue;
                }
                int mid=left+1;
                int right=nums.length-1;
                while(mid<right){
                    int sum=nums[i]+nums[left]+nums[mid]+nums[right];
                    if(sum==target){
                        res.add(Arrays.asList(nums[i],nums[left],nums[mid],nums[right]));
                        while(mid<right&&nums[mid]==nums[mid+1]) mid++;
                        while(mid<right&&nums[right]==nums[right-1]) right--;
                        mid++;
                        right--;
                    }
                    else if(sum>target){
                        right--;
                    }else{
                        mid++;
                    }
                }
            }
        }
        return res;
    }