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

454. 四数相加 II

454. 四数相加 II

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //用hashmap求解,其中key表示a+b只和，value表示出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        for(int i : nums1){
            for(int j : nums2){
                int temp = i + j;
                //判断是否在map中
                if(map.containsKey(temp)){
                    map.put(temp,map.get(temp)+1);
                }
                else{
                    map.put(temp,1);
                }
            }
        }
        int res = 0;
        //再从map中找到0-（key）的键
        for(int i : nums3){
            for(int j : nums4){
                int temp = 0 - (i + j);
                if(map.containsKey(temp)){
                    res += map.get(temp);
                }
            }
        }
        return res;
    }
}

383. 赎金信

383. 赎金信

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        //使用hash数组，节约资源
        //定义一个长度26的数组，其中下标表示magazine中的字母，数组中的值表示在magzine中出现的次数
        //此题的重点是：1.magazine中的每个字符只能在ransomnote中使用一次
        int[] arr = new int[26];
        //遍历magzine字符串，并填入arr hash数组中
        for (char c : magazine.toCharArray()){
            arr[c - 'a'] += 1;
        }
        //遍历ransomnote字符串
        for (char c : ransomNote.toCharArray()){
            arr[c - 'a'] -=1;
        }
        //最后检查arr数组中有没有<0 的元素
        for( int i : arr){
            if(i < 0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

15. 三数之和
要点是：三元组的去重和双指针的应用

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //使用双指针方法解决三数之和
        List<List<Integer>> result = new ArrayList<>();
        //先将nums中的元素进行排序
        Arrays.sort(nums);
        //找出a+ b+ c = 0
        //nums[i] = a ;nums[left] = b;nums[right] = c;
        for (int i = 0 ; i < nums.length ; i++){
            int left = i + 1;
            int right = nums.length - 1;
            //如果排序后的第一个元素的值> 0 则说明在该a条件下的三元组不存在
            if (nums[i] > 0){
                return result;
            }
            //去重a
            if (i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            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]));
                     // 去重逻辑应该放在找到一个三元组之后，对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. 四数之和

思路：使用四个指针(a<b<c<d)。固定最小的a和b在左边，c=b+1,d=_size-1 移动两个指针包夹求解。
保存使得nums[a]+nums[b]+nums[c]+nums[d]==target的解。偏大时d左移，偏小时c右移。c和d相
遇时，表示以当前的a和b为最小值的解已经全部求得。b++,进入下一轮循环b循环，当b循环结束后。
a++，进入下一轮a循环。 即(a在最外层循环，里面嵌套b循环，再嵌套双指针c,d包夹求解)。

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++) {
		
            // nums[i] > target 直接返回, 剪枝操作
            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) {
		    // nums[k] + nums[i] + nums[left] + nums[right] > target 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;
    }
    
}