【算法第五天7.18】四数相加||，三数之和，四数之和，赎金信

链接：力扣454-四数相加||
思路：
map的含义：：key为两数和，value为两数和出现几次
**map.get(key)**得到的是对应的value
1、借鉴两数之和的思想，将前两数与后两数分别求和
2、前两数求和：如果已经包含，则将map的value取出 +1，未包含，则直接put，value为1
3、后两数求和：0-sum1，map中如果有这个数，则让现有的count+取出的value值，最后全部循环完毕，返回count

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int sum1 = 0;
        int sum2 = 0;
        int count = 0;
        // map第一个元素，sum1值，第二个元素：sum1出现次数，这样到后面两数也容易统计次数
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums1.length; i++){
            for(int j = 0; j < nums2.length; j++){
                sum1 = nums1[i] + nums2[j];
                // 这里统计好某个和在map中出现几次
                if(map.containsKey(sum1)){
                    map.put(sum1,map.get(sum1)+1);
                }else{
                    map.put(sum1,1);
                }
            }
        }
        for(int i = 0; i < nums3.length; i++){
            for(int j = 0; j < nums4.length; j++){
                sum2 = nums3[i] + nums4[j];
                int tmp = 0 - sum2;
                // 利用前期统计好的两数之和，在这里计算次数
                if(map.containsKey(tmp)){
                    count += map.get(tmp);
                }
            }
        }
        return count;
    }
}

链接：力扣15-三数之和
思路：
1、先根据题意返回值创建集合
2、对已有数组进行排序，以便后序操作
3、因为题中不能出现相同的三元组，所以需要进行去重操作
4、nums[i] == nums[i-1]可以进行去重操作：比如【-1，-1，-1，2】{-1，-1，2}是一个三元组集合，但是-1用的第几个不得而知，如果一二做了组合，二三再做组合，三元组是重复的，所以需要去重，如果后面的-1跟前面的-1重复了，那可以只要后面的，不要前面的，这样就能去重了
5、第一个元素去重并确定三元组后，后两个元素也需要去重

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i++){
            //已经排序：如果三元组中第一个数已经大于0，则一定不存在
            if(nums[0] > 0) return res;
            //保证索引不重复的三元组,判断一个位置的数是不是有重复,如果有，则进行下一次循环
            if(i > 0 && nums[i] == nums[i-1]) continue;
            // 定义除第一个数之外的两个数
            int left = i + 1;
            int right = nums.length-1;
            // 这里用《而不用《=是因为我们最后需要三个数，如果有 = ，则只剩下两数
            while(left < right){
                if(nums[i] + nums[right] + nums[left] > 0) right--;
                else if(nums[i] + nums[right] + nums[left] < 0) left++;
                // 当找到符合条件的三元组时，则需要对三元组两侧去重
                else{
                    // 先将三个数放入数组，再将数组转为集合
                    res.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    // while(left < right){
                    //     if(nums[left] == nums[left+1]) left++;
                    //     if(nums[right] == nums[right-1]) right--;
                    // }
                    // left++;
                    // right--;
                    while(left < right && nums[right] == nums[right-1]) right--;
                    while(left < right && nums[left] == nums[left+1]) left++;
                    //元素去重后，需要继续寻找合适的三元组，所以需要以下操作
                    right--;
                    left++;
                }
            }
            
        }
        return res;
    }
}

链接：力扣18-四数之和
思路：
1、需要两层for循环，同时对这两个起始元素都要去重
2、后续操作与三数之和类似

if(nums[i] > 0 && nums[i] > target) return res;
不加nums[i] > 0，是没有考虑nums[i]后面加的数为负数的情况，

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        // 1、初始化返回集合
        List<List<Integer>> res = new ArrayList<>();
        // 2、对数组排序
        Arrays.sort(nums);
        // 3、进入第一层循环，需要去重操作
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > 0 && nums[i] > target) return res;
            if(i > 0 && nums[i-1] == nums[i]) continue;
            for(int j = i+1; j < nums.length; j++){
                // 3、进入第二层循环也需要去重操作
                if(j > i+1 && nums[j-1] == nums[j]) continue;
                // 4、后面的逻辑跟三数之和类似
                int left = j + 1;
                int right = nums.length - 1;
                while(left < right){
                    if(nums[i] + nums[j] + nums[left] + nums[right] > target) right--;
                    else if(nums[j] + nums[i] + nums[left] + nums[right] < target) left++;
                    else{
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while(left < right && nums[left] == nums[left+1]) left++;
                        while(left < right && nums[right] == nums[right-1]) right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;

    }
}

if(nums[i] > 0 && nums[i] > target) return res;
//这行代码巧妙的排除了力扣中内存溢出的那个例子
long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
//这行代码将和变为long类型，防止内存溢出

链接：力扣383-赎金信
思路：
1、首先把magazine中的所有字母及其出现次数统计好，这是编成ransomNote的基础
2、ransomNote中用到map中的字母就让其-1，若ransomNote需要的字母magazine中根本没有，则直接返回false;
// 3、最后需要判断map中是否有出现次数小于0的字母，如有，则返回false

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Integer,Integer> map = new HashMap<>();
        // 1、首先把magazine中的所有字母及其出现次数统计好，这是编成ransomNote的基础
        for(int i = 0; i < magazine.length(); i++){
            int tmp = magazine.charAt(i) - 'a';
            if(map.containsKey(tmp)){
                map.put(tmp,map.get(tmp)+1);
            }else{
                map.put(tmp,1);
            }
        }
        // 2、ransomNote中用到map中的字母就让其-1，若ransomNote需要的字母magazine中根本没有，则直接返回false;
        for(int i = 0; i < ransomNote.length(); i++){
            int tmp = ransomNote.charAt(i) - 'a';
            if(map.containsKey(tmp)){
                map.put(tmp,map.get(tmp)-1);
            }else{
                return false;
            }
        }
        // 3、最后需要判断map中是否有出现次数小于0的字母，如有，则返回false
        for(int i = 0; i < magazine.length(); i++){
            if(map.get(magazine.charAt(i) - 'a') < 0) return false;
        }
        return true;
    }
}

字典解法

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // shortcut
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        // 定义一个哈希映射数组
        int[] record = new int[26];

        // 遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }
        
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}