LeetCode刷题day07|454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

一、四数相加Ⅱ

暴力解法会有4层循环，时间复杂度0(n⁴)，显然会超时。然后，当时考虑的是四层不行，那三层怎么样——把第四个数组构造出map哈希表。这样在0(n³)的时间复杂度下可以求出解，但发现依旧超时。
这里其实将原来的四个数组分成两组，相当于抽象成两个数组，这样，又回到两数相加的问题了。
遍历第一个大组中不同元素相加的结果，并将结果存储到map哈希表中，key值为相加的和，value值为等于该和的个数。然后，将另一个大组中的不同小组中的元素同样相加，查询哈希表的key值，看是否有这个相加结果的相反数，若有，则 count（返回的值）+= 哈希表的value值。
以下是代码部分：

//其实按着三个for循环的思路往下想，就可以想到这个题解了。这个是分成两个大的组
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        Map<Integer,Integer> map= new HashMap<>();
        int sum = 0;

        //第一个数组和第二个数组的元素进行整合，并构造哈希表
        for (int i1 : nums1) {
            for (int i2 : nums2) {
                int tmp = i1 + i2;
                if(map.containsKey(tmp)) {
                    map.put(tmp,map.get(tmp)+1);
                }else{
                    map.put(tmp,1);
                }
            }
        }

        //第三个数组和第四个数组的元素进行整合，进行查询哈希表
        for (int i3 : nums3) {
            for (int i4 : nums4) {
                if(map.containsKey(0- i3 - i4)){
                    sum+= map.get(0- i3 - i4);
                }
            }
        }

        return sum;
    }

二、赎金信

这道题其实跟有效的字母异位词242这道题思路上相同。这里就没有什么好展开的，直接附上代码吧。

//基本与有效字母的异位词一样
    public boolean canConstruct(String ransomNote, String magazine) {

        int[] hash = new int[26];

        for (int i = 0; i <magazine.length() ; i++) {
            hash[magazine.charAt(i) - 'a'] ++;
        }

        for (int i = 0; i <ransomNote.length() ; i++) {

            //查询哈希表中还有没有可用的元素
            if(hash[ransomNote.charAt(i) - 'a']>0)
                hash[ransomNote.charAt(i) - 'a']--;
            else
                return false;
        }

        return true;

三、三数之和

这道题目刚做的时候以为需要用到哈希表，但使用哈希表的话需要去重，细节特别多，很麻烦。然后看了题解，不需要用到哈希表，而是通过双指针的思想。
我在这里总结以下需要注意的点：

1. 在Java中定义一个存储List的List语法：

List<List<Integer>> list = new ArrayList<>();

2. 对遍历的元素进行一个剪枝操作：

//如果循环的第一个数大于0，直接return
            if (nums[i] > 0)
                return list;

3. 对三个比较的数（num[i]、num[left]、num[right]）都要进行去重操作，并且去重操作要注意：站在后一个节点的角度去比较前一个节点是否与自己相同，这样的顺序不能错了。

			//对比较的第一个数进行去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;  

			//这里left、right都要更新
                    left++;
                    right--;

                    //注意：这里还要对left、right进行去重
                    while (left<right && nums[left] == nums[left-1])
                        left++;
                    while(left<right && nums[right] == nums[right+1])
                        right--;        

在对num[i]进行去重时，必须要用**nums[i] == nums[i - 1]**判断条件。而在对num[left]、num[right]进行去重时，如果更新（left++;right–;）在前，则是nums[left] == nums[left-1]；如果更新在后，则是nums[left] == nums[left+1]。这里为了让三个数的去重形式上统一，我都是用的与前一个节点比较。

4. Java中向list中添加数组的方式

list.add(Arrays.asList(nums[i], nums[left], nums[right]));

四、四数之和

四数之和问题是在三数之和的基础上在外边再套一层循环，相当于四个数进行比较。当然，这里有几点需要注意的地方，这些地方是四数之和中所特有的需要注意的。

1. 由于题中给的target有可能是负数，所以在剪枝的时候需要额外加一个条件nums[i]>=0
2. 在第二层循环中需要对前两个数的和进行一次判断来进行剪枝。即，每次循环都需要做一次剪枝、一次去重。

//进行剪枝操作
                if(nums[i] + nums[j] >target && target >=0)
                    break;

3. 对第二个数进行去重的时候注意判断条件，要从i+2开始比较前一位。

//对第二个数进行去重
                if( j >i+1 && nums[j] == nums[j-1])
                    continue;     

以下是代码部分：

//在三数之和的基础上加一个外层循环
    public List<List<Integer>> fourSum(int[] nums, int target) {

        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);

        for (int i = 0; i < nums.length-1; i++) {


            //-----------------------第一个细节
            //判断第一个数是否大于target  这里由于target可能为负数，所以不能单独判断大于target
            if(nums[i]>target && nums[i]>=0 )
                return list;



            //对第一个数进行去重
            if( i != 0 && nums[i] == nums[i-1])
                continue;

            //进入第二个循环
            for (int j = i+1; j < nums.length; j++) {


                //-------------------------第二个细节
                //进行剪枝操作
                if(nums[i] + nums[j] >target && target >=0)
                    break;

                //对第二个数进行去重
                if( j !=i+1 && nums[j] == nums[j-1])
                    continue;

                int left = j+1;
                int right = nums.length-1;

                //判断大小
                while (left < right){

                    if(nums[i]+nums[j]+nums[left]+nums[right] < target)
                        left++;
                    else if(nums[i]+nums[j]+nums[left]+nums[right] > target)
                        right--;
                    else {
                        list.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        left++;
                        right--;

                        while (left<right && nums[left] == nums[left-1])
                            left++;
                        while (left<right && nums[right] == nums[right+1])
                            right--;
                    }

                }
            }

        }

        return list;
    }