leetcode刷题打卡 （454. 四数相加 II（中等）、383. 赎金信、 第15题. 三数之和、第18题. 四数之和）

454. 四数相加 II（中等）

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
    0 <= i, j, k, l < n
    nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0      

思路：
    1.看清题目要求，是求四个数组中各取一个元素相加为零的元组个数，不要求去重
    2.选择需要的结构，题目核心是遍历前两个数组，把遍历到的值和次数放到另一个结构中，然后再遍历后两个数组的时候判断是否能在找到0-（ nums3[k] + nums4[l]）以及出现的次数，因此需要使用map集合
    3.把四个数组分成两组，一次嵌套两个for循环，先遍历前两个数组，把遍历到每两个元素的值都添加到map中，值为key，次数为value
    4.每次遍历时，求两个元素的和，并判断map中是否存在，如果存在则value+1，否则value为0.（map.getOrDefault）
    5.遍历后两个数组时，判断map中是否存在0-（ nums3[k] + nums4[l]），如果存在则计数+value
    
class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        int count = 0;
        for(int i : nums1){
            for (int j : nums2){
                int tmp = i + j ;
                map.put(i+j,map.getOrDefault(i+j,0)+1);//getOrDefault(i+j,0)+1,如果存在i+j则对应的Value+1，否则为0
                
            }
        }
        for(int i : nums3){
            for(int j : nums4){
                int tmp = 0 - ( i + j );
                if(map.containsKey(tmp)){
                    count += map.get(tmp);
                }
            }
        }
        
        return count;
    }
}

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

思路：
    1.类似于有效字母异位词，新建一个包含26个字母的数组，遍历ransonNote数组，把对应的字母在新建的数组索引++
    2.遍历第二个字符串magazine，把对应的数组索引--
    3.然后遍历数组，ransomNote字母对应的索引如果>0代表第二个字符串的字母无法构成第一个字符串
class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        int[] arr = new int[26];
        
        for(int i = 0 ;i < ransomNote.length() ; i++){
            arr[ransomNote.charAt(i)-'a']++;
        }
        for(int i = 0 ;i < magazine.length() ; i++){
            arr[magazine.charAt(i)-'a']--;
            
        }
        for(int i = 0 ;i < ransomNote.length() ; i++){
            if(arr[ransomNote.charAt(i)-'a'] > 0){
                return false;
            }
​
    }
    return true;
}
}

第15题. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
​
注意： 答案中不可以包含重复的三元组。

思路：
    1.第一思路是想到两个循环，分别一层和两层，但本题要求去重，所以两层循环很复杂，需要用三指针
    2.首先对数组排序，因为本题只是需要找到符合条件的元素，不需要返回索引，因此可以排序，然后分别定义三个指针
    3.三个指针指向的元素判断与0的关系，如果大于0则right左移，如果小于0，则left右移，否则代表等于0，返回此时三个指针所对应的元素
    4.外层循环控制i，内侧由while控制left和right，并在后边进行去重操作，并且去重操作一定是在记录数值后，否则比如0,0,0将不会被计入，在去重后，还要对left和right分别进行右移和左移操作
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        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){
            if(nums[i]+nums[left]+nums[right] > 0){
                right--;
            }else if(nums[i]+nums[left]+nums[right] < 0){
                left++;
            }
            else{
                res.add(Arrays.asList(nums[i],nums[left],nums[right]));
            
            while(right > left && nums[right] == nums[right-1] ) right--;
            while(right > left && nums[left] == nums[left + 1]  ) left++;
            right--;
            left++;}
        }
        }
        return res;
    }
}

第18题. 四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

思路：
    1.类似于三数之和，不能存在相同元素，不方便用循环去重，因此同样使用多指针操作
    2.定义四个指针，思路于上边三数之和一样，如果四数之和大于target，则right-1，若小于target则left+1，否则将四个值输入到数组，res.add(Arrays.asList(xxx,xxx,xxx,xxx))
    3.要注意去重，去重思路一样，除了j
    4.right--和left++一定放在else内,因为是满足条件后才同时移动
class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        int j;
        int i;
        int left;
        int right;
        Arrays.sort(nums);
        for( j = 0 ; j < nums.length ; j++){
            if(nums[j]>target && nums[j] > 0) return res;
            if(j >0 && nums[j-1] == nums[j] ) continue;
            for( i = j + 1 ; i < nums.length ;i++){
                if(i>j +1 && nums[i - 1] == nums[i] ) continue;
                left = i+1;
                right = nums.length-1;
​
                while(left < right){
                    long sum = (long)nums[j] + nums [i] + nums[left] + nums[right];
                    if(sum > target ) {right--;}
                    else if( sum < target ){left++;}
                    else{ res.add(Arrays.asList(nums[j],nums[i],nums[left],nums[right]));
                    while(left < right && nums[right] == nums[right-1]) right--;
                    while(left < right && nums[left] == nums[left+1]) left++;
                    right --;
                    left ++;//移动指针操作一定要放在else括号内，已经连错了两道题
                }
                }
            }
        }
        return res;
    }
}