算法学习Day5——哈希2

454 四数相加II

454. 四数相加 II - 力扣（LeetCode）

思路：

先算a，b之和，再看减去c，d之和能不能为0，类似两数之和的思路

备注：

Map.getOrDefault(Object key, V defaultValue);
如果在Map中存在key，则返回key所对应的的value。如果在Map中不存在key，则返回默认值。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res=0;
        Map<Integer,Integer> map=new HashMap<Integer,Integer>();
        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){
                int sum=i+j;
                res+=map.getOrDefault(0-i-j,0);
            }
        }
        return res;

    }
}

383 赎金信

383. 赎金信 - 力扣（LeetCode）

使用数组，要注意题目要求是，a能不能被b组成，意思就是b的长度可以大于a也可以有a没有的字母。

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

    }
}

15 三数之和

15. 三数之和 - 力扣（LeetCode）

难点在如何去重，使用哈希比较不合适，可以使用双指针。那为什么要放到哈希这里...

思路：

首先对数组进行片排序，然后有三个指针，i，left，right，i从头开始遍历，left是从i之后的第一个元素开始，right是从最后一个元素开始，如果sum值大了，就right--，如果小了就left++。

注意去重

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++){
            //如果第一个元素已经大于0，则一定不可能凑成
            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(right>left){
                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]));
                    //去重，对b和c去重
                    while(right>left && nums[right] ==nums[right-1] ) right--;
                    while(right>left && nums[left] ==nums[left+1] ) left++;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

18 四数之和

18. 四数之和 - 力扣（LeetCode）

延续三数之和思路。比较坑的是int会溢出。

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 - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while(right>left){
                    //int 会溢出
                    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]));
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}