算法Day6 | Leetcode454题.四数相加II、383. 赎金信、15.三数之和、18. 四数之和

454题.四数相加II

力扣链接

思路

因为只需要返回满足条件的个数，无需关注下标只用关注结果，分成两组，算AB的和的集合，再去算CD的和，用零减去和判断在AB集合里面是否存在

代码

HashMap

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                int sum=nums1[i]+nums2[j];
                map.put(sum,map.getOrDefault(sum,0)+1);
            }
        }

        int count=0;
        for(int i=0;i<nums3.length;i++){
            for(int j=0;j<nums4.length;j++){
                int need=0;
                need-=(nums3[i]+nums4[j]);
                count+=map.getOrDefault(need,0);
            }
        }

        return count;
    }
}

383. 赎金信

力扣链接

思路

跟前一天的基本上一模一样，记录一下不长记性。由小写字母组成，可以用数组代替Map

代码

HashMap

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character,Integer> map=new HashMap<>();
        for(int i=0;i<magazine.length();i++){
            char m=magazine.charAt(i);
            map.put(m,map.getOrDefault(m,0)+1);
        }

        for(int i=0;i<ransomNote.length();i++){
            char r=ransomNote.charAt(i);
            if(!map.containsKey(r)||map.get(r)==0) return false;
            map.put(r,map.get(r)-1);
        }

        return true;
    }
}

数组

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] directory=new int[26];
        for(int i=0;i<magazine.length();i++){
            char m=magazine.charAt(i);
            directory[m-'a']++;
        }

        for(int i=0;i<ransomNote.length();i++){
            char r=ransomNote.charAt(i);
            if(directory[r-'a']==0) return false;
            directory[r-'a']--;
        }

        return true;
    }
}

15.三数之和

力扣链接

思路

用双指针来解决。比较需要注意的就是去重，是下标i和下标i-1相等的时候跳，如果是和下标i+1相等的时候跳的话，会漏掉结果，比如{-1，-1，2}也是一种结果，但是上面的判断条件会漏

代码

如果不能用排序算法的话就加一段冒泡排序法

for(int i=1;i<nums.length;i++){
            for(int j=0;j<num.length-i;j++){
                if(nums[j]>nums[j+1]){
                    int temp=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=temp;
                }
            }
        }

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        Arrays.sort(nums);
        int i=0;
        while(i<nums.length){
            if(i==0 || nums[i]!=nums[i-1]){
                int slow=i+1;
                int fast=nums.length-1;
                while(slow<fast){
                    int sum=nums[i]+nums[slow]+nums[fast];
                    if(sum>0) fast--;
                    else if(sum<0) slow++;
                    else{
                        List<Integer> list=new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[slow]);
                        list.add(nums[fast]);
                        result.add(list);
                        slow++;
                        fast--;
                        while(slow<fast&&nums[slow]==nums[slow-1]) slow++;
                        while(slow<fast&&nums[fast]==nums[fast+1]) fast--;
                    }
                }
            }
            i++;
        }
        return result;
    }
}

18. 四数之和

力扣链接

思路

这个相比于三数之和是在外面多一层循环，以外面两层循环为结果来双指针查找是否存在满足target的组合。每多一个数相加就多一层循环。这里如果需要剪枝的话可以通过判断nums[i]大于0且比target大来写，但是时间复杂度是没有变的。还有一个点就是这里要注意4个10的九次方会比Integer.MAX_VALUE要大，用long来存。（^^提交的时候发现这个测试用例过不去，之前也写到别的题超长字符串过不去，后面再改吧）

代码

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++){
            for(int j=i+1;j<nums.length;j++){
                if(i==0 || nums[i]!=nums[i-1]){
                    if(j==i+1 || nums[j]!=nums[j-1]){
                        int slow=j+1;
                        int fast=nums.length-1;
                        while(slow<fast){
                            long need=(long) target-nums[i]-nums[j]-nums[slow]-nums[fast];
                            if(need>0) slow++;
                            else if(need<0) fast--;
                            else{
                                ArrayList<Integer> list=new ArrayList<>();
                                list.add(nums[i]);
                                list.add(nums[j]);
                                list.add(nums[slow]);
                                list.add(nums[fast]);
                                result.add(list);
                                slow++;
                                fast--;
                                while(slow<fast&&nums[slow]==nums[slow-1]) slow++;
                                while(slow<fast&&nums[fast]==nums[fast+1]) fast--;
                            }
                        }
                    }
                }
            }
        }
        return result;
    }
}