算法训练第七天 | LeetCode 454、383、15、13

LeetCode 454 四数相加II

题目简析：给四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请计算有多少个元组 (i, j, k, l) 能满足指定条件

思路分析：类似两数之和，两两组队，统计出现次数，在后面去查找是否出现前两者的和的情况时，采用的方法类似两数之和，就是去找表中是否有指定值和当前值的差值。用Map是因为题目只需要统计次数，只求结果，后面的四数相加，求的是过程。

    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;
                //若出现过了，则次数+1
                if(map.containsKey(temp)){
                    map.put(temp,map.get(temp)+1);
                }else {
                    map.put(temp,1);
                }
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i : nums3) {
            for (int j : nums4) {
                temp = i + j;
                //这里的操作与两数之和后面的操作类似
                //0-temp去查找map中是否有两者的差值，如果有，说明能凑成0
                if (map.containsKey(0 - temp)) {
                    res += map.get(0 - temp);
                }
            }
        }
        return res;
    }

 

---

LeetCode 383赎金信

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

思路分析：这道题个与前面的异位词大体上相似，但是细读题目发现有点区别，两字符串是包含关系，所以导致哈希表在++，--的时候不再以最后是否为0为判断标准，而是是否大于0，若等于0或者小于0，说明是包含关系，则可以返回true

    public boolean canConstruct(String ransomNote, String magazine) {
        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 < 26; i++) {
            if(arr[i] > 0){
                return false;
            }
        }
        return true;
    }

---

LeetCode 15三数之和

题目简析：判断是否存在满足条件的三元组  。最后返回所有和为 0 且不重复的三元组，同时答案中不可以包含重复的三元组

思路分析：代码注释很清晰了，此题值得回味细品

    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>>arr = new ArrayList<>();
        //先排序，因为输出顺序和原顺序并不重要
        Arrays.sort(nums);
        int len = nums.length;
        //for循环里设立两个指针
        for (int i = 0; i < len; i++) {
            if(nums[i]>0){
                //若单个元素都大于0了说明后面更不可能和为0
                return arr;
            }
            //去重-----这里我们去重的应该是把当前位和它前一位进行比较
            //  ------若比较的是当前位和它后一位，那么就会跳过比较情况
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            int left = i+1;
            int right = len-1;
            while(right>left){
                int sum = nums[i]+nums[left]+nums[right];
                //检索三元组
                if(sum>0){
                    //说明right位置的元素取大了，回退取小的
                    right--;
                }else if(sum<0){
                    //说明left位置的元素取小了，前进取大的
                    left++;
                }else {
                    //此时找到三元组
                    arr.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    //加入当前数后，因为不能填入重复三元组，所以指针移动
                    //如何移动？
                    //若右指针出现与左边重复的元素说明要移动有右指针
                    //eg. {-2,0,1,2,2}
                    //第一个三元组为{-2,0,2}，这个正2是最右边的
                    //假设直接往左移，发现倒数第二个还是正2，此时加入三元组可以发现三元组重复
                    //所以进行去重操作
                    while(right>left && nums[right]==nums[right-1]){
                        right--;
                    }
                    while(right>left && nums[left] == nums[left+1]){
                        left++;
                    }
                    //去重成功，让两者再挪动一次开始新一轮的比较
                    right--;
                    left++;
                }
            }
        }
        return arr;
    }

---

 LeetCode 18四数之和

题目简析：给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。找出并返回满足指定全部条件且不重复的四元组

思路分析：见代码注释，上道题明白了其实这道题并不难了，大部分操作一致，但是注意一点就是，因为是四元组，所以要多一层循环

    public List<List<Integer>> fourSum(int[] nums, int target) {
        //本题类似三数之和，关键点就是把目标是0替换为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]) {
                continue;
            }
            //因为是四元组，要比三元组多一层循环，从i+1开始找四元组
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j - 1] == nums[j]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
                    //这类加入四元组的操作一致，注意类型不再是int，要long才够
                    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]));
                        //去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;
                        //去重完成，再次移动指针，进行新一轮的比较
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }