代码随想录算法训练营第⑦天 | 454.四数相加II ，383. 赎金信，15. 三数之和，18. 四数之和 9.30

代码随想录算法训练营第⑦天 | 454.四数相加II ，383. 赎金信，15. 三数之和，18. 四数之和 9.30

454.四数相加II

1. 可以先用2次for循环遍历前两个数组a,b 并存储到map中 key存a+b value存出现的次数
2. 然后用2次循环遍历后两个数组 判断Map中是否有相加等于0的key 然后结果加上key对应value中的值
3. 因为数值可以重复 所以在存储的时候 如果之前已经存过相同值的 就value+1

import java.util.Map;
import java.util.HashMap;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> hashtable = new HashMap<>();
        Integer temp;
        int res = 0;
        for(int i : nums1){
            for(int j : nums2){
                temp = i+j;
                if(hashtable.containsKey(temp)){
                    hashtable.put(temp,hashtable.get(temp)+1);
                }else{
                    hashtable.put(temp,1);

                }

            }
        }

        for(int k : nums3){
            for(int l : nums4){
                if(hashtable.containsKey(0-(k+l))){
                    res+=hashtable.get(0-(l+k));
                }

            }
        }

        return res;


    }
}

383. 赎金信

1. 此题与之前做过的比对两个字符串题类似 思路同样是用哈希表存一个字符串 再用另一个来比对减

map做法

import java.util.Map;
import java.util.HashMap;


class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer> map = new HashMap();
        for(int i =0; i<ransomNote.length();i++){
            if(map.containsKey(ransomNote.charAt(i))){
                map.put(ransomNote.charAt(i),map.get(ransomNote.charAt(i))+1);
            }else{
                map.put(ransomNote.charAt(i),1);
            }
        }

        for(int i=0; i<magazine.length();i++){
            if(map.containsKey(magazine.charAt(i)) && map.get(magazine.charAt(i))!=0){
                map.put(magazine.charAt(i),map.get(magazine.charAt(i))-1);
            }
        }
        
        Set<Character> keys = map.keySet();
        for(Character key: keys){
            int value = map.get(key);
            if(value!=0){
                return false;
            }
        }
        return true;
        
        
    }
}

用数组作为哈希表

1. 因为题中只有小写字母 所以数组长度固定为26 用来记录magazine 中字母出现的次数

import java.util.Map;
import java.util.HashMap;


class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] hash = new int[26];

        for(char c: magazine.toCharArray()){
            hash[c - 'a']+=1;
        }

        for(char c : ransomNote.toCharArray()){
            hash[c - 'a']-=1;
        }


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

15. 三数之和

1. 用哈希表的话 需要存a+b的值 但是因为数组Nums中有重复元素 所以a b c 都需要去重 有点困难
2. 因为题目不需返回索引下标 所以排序后 从第一个开始遍历 然后用双指针搜索后面的区间
3. 如果偏大就把right左移 偏小就把left右移 也需要对 i left right 去重 防止结果集有重复结果
4. 去重复的思路 就是这组取了结果 假如下一个元素值和上一个一样 那么就需要跳过去

class Solution {
    public 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 && 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{
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                
                    //取了一组结果之后 判断和下一个是否值相等 若相等则跳过
                    //还需让满足 left<right 防止超出数组范围
                    while(left<right && nums[left]==nums[left+1]){
                        left++;
                    }
                    while(left<right && nums[right]==nums[right-1]){
                        right--;
                    }

                    right--;
                    left++;


                }   
            }

        


    }
    return res;
}
}

18. 四数之和

1. 整体思路还是双指针 多了一层循环
2. 去重时使用一样的思路 就是下一位不可以等于前一位 若等于就跳过

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);

        for(int i=0;i<nums.length;i++){
            //剪枝
            if(nums[i]>0 && nums[i]>target){
                return res;
            }

            //去重
            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;
                }

                int left = j+1;
                int right = nums.length-1;

                while(left<right){
                    int sum = nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum>target){
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));

                        //对left right 去重
                        while(left<right && nums[left]==nums[left+1]){
                            left++;
                        }

                        while(left<right && nums[right]==nums[right-1]){
                            right--;
                        }

                        left++;
                        right--;



                    }

                }

            }
        }
        return res;

    }
}