lc哈希表（相加|赎金信|三数及两数之和）

454.四数相加

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
解题思路：用hashmap1保存前两个数组的所有和的可能，出现几次就给value赋几，然后用sum34保存后两个数组的所有和的相反数，每保存一次就判断hashmap1中知否有对应的key，有的话就获取对应key的value值，也就是出现了几次。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer,Integer> hashMap1=new HashMap<>();
        int ans=0;
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                int sum12=nums1[i]+nums2[j];
                if(hashMap1.containsKey(sum12)){
                    hashMap1.put(sum12,hashMap1.get(sum12)+1);
                }else{
                    hashMap1.put(sum12,1);
                }
            }
        }
        for(int i=0;i<nums3.length;i++){
            for(int j=0;j<nums4.length;j++){
                int sum34=-(nums3[i]+nums4[j]);
                if(hashMap1.containsKey(sum34)){
                    ans+=hashMap1.get(sum34);
                }
            }
        }

    return ans;
    }
}

383.赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

解题思路： 判断ransomNote是否是magazine的子集,再判断map2里面可以找到所有map1里面的值,如果不存在为false，如果map2里面的字符出现的次数比map1中出现的次数小也返回false，否则返回true；

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character,Integer> hashMap1=new HashMap<>();
        HashMap<Character,Integer> hashMap2=new HashMap<>();
        putInHash(ransomNote,hashMap1);
        putInHash(magazine,hashMap2);
        for(Map.Entry<Character,Integer> entry:hashMap1.entrySet()){
            if(!hashMap2.containsKey(entry.getKey())){
                return false;
            }
            if(hashMap2.get(entry.getKey())<entry.getValue()){
                return false;
            }
        }
         return true;
    }
    public void putInHash(String str,HashMap<Character,Integer> hashMap){
        for(int i=0;i<str.length();i++){
            if(hashMap.containsKey(str.charAt(i))){
             int temp=hashMap.get(str.charAt(i))+1;
            hashMap.put(str.charAt(i),temp);
            }
            else{
                hashMap.put(str.charAt(i),1);
            }
        }

    }
}

15.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

class Solution {
        public  List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans=new ArrayList<>();
        Arrays.sort(nums);//对数组进行排序,遍历排序后数组：
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0){
                break;//因为已经排序好，如果大于0就跳出循环，因为后面不可能相加为0
            }
            if(i>0 && nums[i]==nums[i-1]){
                continue;//对于重复元素：跳过，避免出现重复解.
            }
            int left=i+1;
            int right=nums.length-1;//令左指针 L=i+1L=i+1，右指针 R=n−1R=n−1，当 L<RL<R 时，执行循环：
            while (left<right){
                int sum=nums[i]+nums[left]+nums[right];
                if(sum<0){//若和小于 0，说明 nums[L]nums[L] 太小，LL 右移
                    left++;
                }else if(sum>0){// 若和大于 0，说明 nums[R]nums[R] 太大，RR 左移
                    right--;
                }else {//当 nums[i]+nums[L]+nums[R]==0nums[i]+nums[L]+nums[R]==0，执行循环，
                    List<Integer> list1=new ArrayList<>();
                    list1.add(nums[i]);
                    list1.add(nums[left]);
                    list1.add(nums[right]);
                    ans.add(list1);
                    while (right<i && nums[right]==nums[right-1]){// 判断左界和右界是否和下一位置重复，去除重复解。
                        right--;
                    }
                    while (left<right && nums[left]==nums[left+1]){
                        left++;
                    }
                    right--; // 并同时将 L,RL,R 移到下一位置，寻找新的解。
                    left++;
                     }
            }
        }
        return ans;
   }
}

18.两数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

    0 <= a, b, c, d < n
    a、b、c 和 d 互不相同
    nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

解题思路：使用四个指针(a<b<c<d)。固定最小的a和b在左边，c=b+1,d=_size-1 移动两个指针包夹求解。
保存使得nums[a]+nums[b]+nums[c]+nums[d]==target的解。偏大时d左移，偏小时c右移。c和d相
遇时，表示以当前的a和b为最小值的解已经全部求得。b++,进入下一轮循环b循环，当b循环结束后。
a++，进入下一轮a循环。 即(a在最外层循环，里面嵌套b循环，再嵌套双指针c,d包夹求解)。

class Solution {
    /**
     * 四元组的和为target
     *
     * @param nums
     * @param target
     * @return
     */
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if (nums[i] > target && (nums[i] >= 0 || target >= 0)) {//target可以是负数也可以是正数,因为是负数的话，
            //我们要是直接判断>target就返回的话是会出错的。
                return ans;
            }
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i+1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int left = j + 1, right = nums.length - 1;
                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        ans.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        right--;
                        left++;
                    }
                }
            }
        }
        return ans;
    }
}