【代码随想录算法训练营第六天| ● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 ● 18. 四数之和

454 四数相加        计算前三数的和与第四数进行比较判断，优化为计算前两数的和与后两数的和进行比较判断，利用hashmap存储两数的和；
统计出现的次数, 在java中可以使用map类中的方法进行实现.countAB.put(u + v, countAB.getOrDefault(u + v, 0) + 1), 这里比较重要的是getOrDefault(u + v, 0)方法, 它的含义是获得键u + v对应的值, 也就是出现的次数, 如果当然哈希表中未出现, 则返回默认值0. 通过后面的+1操作, 实现在现有次数上+1或者初始化次数为1, 然后将这个键值对放入到哈希表中

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

        }
        int count = 0;
        for (int i : nums3) {
            for (int j : nums4) {
                if (onetwosum.containsKey(-(i + j))) {
                    count += onetwosum.get(-(i + j));
                }
            }

        }
        return count;
    }
}

 383. 赎金信 与242.有效的字母异位词 相似 利用哈希数组记录字符串中一个字符的数量，用26个索引记录出现的字符；当某处哈希数组值不为0则不成立；

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

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

三数之和        排序便于去重，先找第一个数字i，利用双指针分别代表j和k，对找到的每个i进行遍历，当i+j+k>0时k减小，i+j+k<0时j增加；由于数组存在相同元素需要进行去重，对i去重是由于该组合已经找过了不需要再次返回该结果；对j和k去重是由于下一元素与上一元素相同，j++，k--hou取值相同返回同一结果么有意义需要继续移动。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        // a = nums[i], b = nums[left]=j, c = nums[right]=k
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) { // 排序后i<=j<=k,i>0那么i+j+k一定大于0
                return result;
            }

            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;//k变小
                } else if (sum < 0) {
                    left++;//j变大
                } else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    //输出为三元组
		            // 去重逻辑应该放在找到一个三元组之后，对j 和 k去重
                    while (right > left && nums[right] == nums[right - 1])
                         right--;
                    while (right > left && nums[left] == nums[left + 1]) 
                          left++;
                    right--; 
                    left++;
                }
            }
        }
        return result;
    }

}

四数之和        在三数之和的基础上可以先确定i，j两个数的值，然后用双指针进行判断。需要对j也进行去重

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++) {
            // nums[i] > target 直接返回, 剪枝操作
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
            if (i > 0 && nums[i - 1] == nums[i]) { // 对nums[i]去重
                continue;
            }
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j - 1] == nums[j]) { // 对nums[j]去重
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
                    int sum = 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;
    }
}

总结 哈希表的用法

数组、数组空间大小比较小

set       数组空间够大但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费

map set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。map是一种<key, value>的结构，本题可以用key保存数值，用value在保存数值所在的下标。所以使用map最为合适。