DAY06 || 454.四数相加|| 383.赎金信 15.三数之和 18.四数之和

454.四数相加||

代码示例

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

心得体会

首先接收四个整数数组作为参数，然后使用哈希表来统计前两个数组中元素之和的出现次数。具体来说，函数使用两个for循环遍历nums1和nums2中的元素，将它们相加得到temp，然后将temp作为key，出现次数作为value存入map中。接着，遍历nums3和nums4中的元素，将它们相加得到temp，然后在map中查找是否存在0-temp的key，如果存在，则将对应的value累加到结果res中。最后，返回res作为结果。

383.赎金信

代码示例

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] arr = new int[26];
        int temp;
        for (int i = 0; i < magazine.length(); i++) {
            temp = magazine.charAt(i) - 'a';
            arr[temp]++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            temp = ransomNote.charAt(i) - 'a';
            if (arr[temp] > 0) {
                arr[temp]--;
            } else {
                return false;
            }
        }
        return true;
    }
}

心得体会

方法通过记录第二个字符串中每个字符出现的次数，然后遍历第一个字符串中的每个字符，查找它是否在第二个字符串中出现过。如果出现过，就将对应字符的计数减一，否则返回false。如果第一个字符串中的每个字符都在第二个字符串中出现过，就返回true。

15.三数之和

代码示例

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        for (int first = 0; first < n; ++first) {
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            int third = n - 1;
            int target = -nums[first];
            for (int second = first + 1; second < n; ++second) {
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    ans.add(list);
                }
            }
        }
        return ans;
    }
}

心得体会

首先按升序对输入数组进行排序。然后它遍历数组中的每个元素，将其视为潜在三元组的第一个元素。为避免重复，它跳过与前一个元素相同的任何元素。
对于每个潜在的三元组，代码将目标值设置为第一个元素的负值。然后使用两个指针，一个从第二个元素开始，另一个从数组的末尾开始，找到其余两个元素，使它们的和等于目标值。为避免重复，它跳过与前一个元素相同的任何元素。如果第二个和第三个元素的和等于目标值，则将三元组添加到答案列表中。
 

18.四数之和

代码示例

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> quadruplets = new ArrayList<List<Integer>>();
        if (nums == null || nums.length < 4) {
            return quadruplets;
        }
        Arrays.sort(nums);
        int length = nums.length;
        for (int i = 0; i < length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
            if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            for (int j = i + 1; j < length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                    break;
                }
                if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                    continue;
                }
                int left = j + 1, right = length - 1;
                while (left < right) {
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        quadruplets.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        left++;
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return quadruplets;
    }
}

心得体会

首先函数接受一个整数数组和一个目标整数作为输入，并返回一个包含所有四元组的列表，这些四元组的和等于目标整数。函数首先对输入数组进行排序，然后使用四个嵌套的循环来查找四元组。在第一个循环中，我们选择第一个元素，并跳过重复的元素。在第二个循环中，我们选择第二个元素，并跳过重复的元素。在第三个循环中，我们使用双指针技术来查找第三个和第四个元素，使它们的和等于目标整数。如果找到了这样的四元组，我们将其添加到结果列表中。如果和小于目标整数，我们将左指针向右移动，否则我们将右指针向左移动。如果和等于目标整数，我们将左指针向右移动并跳过重复的元素，将右指针向左移动并跳过重复的元素。