day07 454 383 15 18

leetcode第454题.四数相加II

使用暴力解法的话 需要四个for循环 也就是 时间复杂度O（n^4）显然超时，
可以把题目拆成 两个O（n^2）的问题
具体做法：先遍历前两个数组 O（n^2）然后利用hashmap ；key 存放前两个数组组合产生的数，value记录出现次数

遍历完前两个数组后， 再遍历后两个数组 ，通过判断条件nums3+nums4=（0-nums1-nums2）来找出符合条件的组合，记录出现次数；

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map=new HashMap<>();
        int res=0;
        for(int count1:nums1){
            for(int count2:nums2){
                int temp=count1+count2;
                if(map.containsKey(temp)){       
                    map.put(temp,map.get(temp)+1);  //value 是在原有的基础上+1 而不是直接设置为1
                }else{
                    map.put(temp,1);
                }

            }
        }
        for(int count1:nums3){
            for(int count2:nums4){
                int temp=count1+count2;
                if(map.containsKey(0-temp)){
                    res+=map.get(0-temp);
                }

            }
        }
        return res;

    }
}

leetcode383

解题思路

此处撰写解题思路
本题和242.有效的字母异位词基本一致，利用一个记录数组来记录元素出现的次数，遍历遍历第一个数组让元素++，遍历第二个让元素--；最后对这个记录数组进行遍历，如果有负数，则不满足条件；

代码

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

    }
}

15. 三数之和

双指针法，将原本暴力O(n^3) 的解法，降为O(n^2) 的解法

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);        //先对数组排序
        for(int i=0;i<nums.length;i++){  //遍历  当 nums[i](充当第一个元素)大于0，则不需要继续遍历了
            if(nums[i]>0){
                return result;
            }
            if(i>0&&nums[i]==nums[i-1]){
                continue;            //有重复 跳出本次循环
            }
            int left=i+1;
            int right=nums.length-1;
            while(left<right){
                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] == nums[right - 1]) right--;//对两个指针去重
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    
                    right--; 
                    left++;
                }
            }      
        }
        return result;


    }
}

leetcode 四数之和 四数之和的双指针解法就是将原本暴力O(n^4) 的解法，降为O(n^3) 的解法。
对比三数之和 多一层的for循环，其他操作和三数之和基本一样。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res= new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0&&nums[i]>target) return res;    //排除掉 最小的数都已经大于target的情况
            if(i>0&&nums[i-1]==nums[i]) continue;    //有前后重复 跳过本次循环
            for(int j=i+1;j<nums.length;j++){   //第二个数 i+1 开始
                if(j>i+1&&nums[j]==nums[j-1]) continue;  //和前一个有重复  跳过这个循环
                int left=j+1;
                int right=nums.length-1;
                while(right>left){ 
                    long sum=(long)nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum>target){
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        while(right>left && nums[left]==nums[left+1]) left++;  //重复的情况跳过
                        while(right>left && nums[right]==nums[right-1]) right--;
                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
    }
}