代码随想录|454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和

public class Day6 {
    //给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
要记录多少元组，即不仅用到nums[i]数值,还要记录次数，所以用map存储
先将num1加num2所有可能得到的数加入map并且记录次数，在map中再次筛选遍历num3和num4所有的和的相反数，有的话就将map中存储的对应次数加到result中。
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer,Integer> map=new HashMap<>();
        int result=0;
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum, 0) + 1);//新put的key的value键会覆盖相同的key的value值
            }
        }
        for(int i:nums3){
            for (int j:nums4){
                if(map.containsKey(-j-i)){
                    result+=map.get(-j-i);
                }
            }
        }
        return result;
    }
    //给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
    //如果可以，返回 true ；否则返回 false 。
    //magazine 中的每个字符只能在 ransomNote 中使用一次。
分别记录26个字母次数，ransomNote有的就加加，magazine有的话就减减
最后看是否为0；
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] count=new int[26];
        for(int i=0;i<ransomNote.length();i++){
            count[ransomNote.charAt(i)-'a']++;
        }
        for(int i=0;i<magazine.length();i++){
            count[magazine.charAt(i)-'a']--;
        }
        for(int i:count)
            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 且不重复的三元组。
    //注意：答案中不可以包含重复的三元组。

        双指针法：先给数组排序，i指向头部，left指向i的下一个，right指向最后一个，通过三个指针对应的数值和大于小于0来移动指针。
                        
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0) return result;
            if (i>0&&nums[i]==nums[i-1]) //去重 因为返回的是不重复的数值，不去重会重复得到之前得到的重复数值。
    
                continue;
            int left=i+1,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]));
                    while(right>left&&nums[right-1]==nums[right])
                            right--;//去重逻辑应该在存储过一个三元组以后
                    while(right>left&&nums[left+1]==nums[left])
                            left++;
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
    //给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。
    // 请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]]
    // （若两个四元组元素一一对应，则认为两个四元组重复）：
在三元组基础上加了一个for循环，修改对应的剪纸和去重操作
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result=new ArrayList<>();
        Arrays.sort(nums);
        for(int k = 0; k < nums.length; k++) {
            if(nums[k]>target&&(nums[k]>0||target>0))
                return result;
            if (k > 0 && nums[k] == nums[k - 1])
                continue;
            for (int i = k+1; i < nums.length; i++) {
         
                if (i > k+1 && nums[i] == nums[i - 1])
                    continue;
                int left = i + 1, right = nums.length - 1;
                while (right > left) {
                    int sum = nums[i] + nums[left] + nums[right]+nums[k];
                    if (sum > target)
                        right--;
                    else if (sum < target)
                        left++;
                    else {
                        result.add(Arrays.asList(nums[i], nums[left], nums[right],nums[k]));
                        while (right > left && nums[right - 1] == nums[right])
                            right--;
                        while (right > left && nums[left + 1] == nums[left])
                            left++;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}