开始学算法6===＞哈希表进阶+双指针进阶（LeetCode刷题！！！）

跟着carl哥的第六天

今天两道哈希表，两道双指针

哈希表进阶

先看第一道题

leetcode454. 四数相加 II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

示例1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

思路：
这道题你可以把两个数看成一个数，然后就像昨天那篇文章的 leetcode1.两数之和 一个思想了，要注意的是把两个数看成一个数 要用什么数据结构呢？ 需要存储两数相加的值 以及统计出现的次数

---

答案：：：

public class test01 {

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {

        //读入一行，并按照空格拆分
        String[] nums1 = in.readLine().split(",");
        String[] nums2 = in.readLine().split(",");
        String[] nums3 = in.readLine().split(",");
        String[] nums4 = in.readLine().split(",");
        int[] arr1 = new int[nums1.length];
        int[] arr2 = new int[nums1.length];
        int[] arr3 = new int[nums1.length];
        int[] arr4 = new int[nums1.length];
        for (int i = 0; i < nums1.length; i ++) {

            arr1[i] = Integer.parseInt(nums1[i]);
            arr2[i] = Integer.parseInt(nums2[i]);
            arr3[i] = Integer.parseInt(nums3[i]);
            arr4[i] = Integer.parseInt(nums4[i]);
        }

        int count = fourSumCount(arr1, arr2, arr3, arr4);

        out.write(count);
        out.flush();
        out.close();
    }

    private static int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        //把四个数变成 两两相加的数（并且记录出现的次数）
        int count = 0; //记录满足的个数
        int temp = 0; //中间值："两数相加"

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

        //前两数相加
        for (int i = 0; i < nums1.length; i ++) {
            for (int j = 0; j < nums1.length; j ++) {
                temp = nums1[i] + nums2[j];
                if (map.containsKey(temp)) {
                    map.put(temp, map.get(temp) + 1);
                } else {
                    map.put(temp, 1);
                }
            }
        }

        //后两数相加再验证()
        for (int i = 0; i < nums1.length; i ++) {
            for (int j = 0; j < nums1.length; j ++) {
                temp = nums3[i] + nums4[j];
                if (map.containsKey(0 - temp)) {
                    count += map.get(0 - temp);
                }
            }
        }

        return count;
    }
}

---

再看第二道题

leetcode383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

示例1 :

输入：ransomNote = "a", magazine = "b"
输出：false

示例2 :

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例3 :

输入：ransomNote = "aa", magazine = "aab"
输出：true

思路：这道题跟昨天文章的leetcode242.有效的字母异位词有点像，大家可以试着做做，我在答案里写了做题时的思想

---

答案：

public class test02 {

    //定义输入输出
    public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) throws IOException {

        //读入一行，并按照空格拆分
        String ransomNote = in.readLine();
        String magazine = in.readLine();

        boolean flag = canConstruct(ransomNote, magazine);

        System.out.println(flag);
        out.flush();
        out.close();

    }

    //magazine中所有的字母可以组成ransomNote 并且magazine中的每个字符只能使用一次
    private static boolean canConstruct(String ransomNote, String magazine) {

        boolean flag = false;

        //感觉得用map 因为magazine中每个字符只能用一次
        //所以key记录字符，value记录字符数目
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < magazine.length(); i ++) {

            //如果map中存在该字符，则++, 如果没包含则加入到map
            if (map.containsKey(magazine.charAt(i))) {
                map.put(magazine.charAt(i), map.get(magazine.charAt(i)) + 1);
            } else {
                map.put(magazine.charAt(i), 1);
            }
        }

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

            //如果map中存在该字符，则--, 如果没有则返回false
            if (map.containsKey(ransomNote.charAt(i))) {
                map.put(ransomNote.charAt(i), map.get(ransomNote.charAt(i)) - 1);
                flag = true;
                if (map.get(ransomNote.charAt(i)) < 0) {
                    flag = false;
                    break;
                }
            } else {
                return false;
            }
        }



        return flag;
    }
}

双指针进阶

第一道题

leetcode15.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

思路：

• 使用双指针法， 一个指针指向左边界（i的下一位），一个指针指向右边界，还有一个for循环的i ， 大概意思就是定住i 然后两个指针往中间遍历，寻找合适的值sum
• 如果 sum > 0 则右边界左移(right --)，sum < 0 则左边界右移(left ++)
• 因为数组不能重复，所以需要判重
• 可以想想可以怎么剪枝

---

答案：

public class test03 {

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {

        //读入一行，并按照空格拆分
        String[] nums = in.readLine().split(",");
        int[] arr = new int[nums.length];
        for (int i = 0; i < nums.length; i ++)
            arr[i] = Integer.parseInt(nums[i]);

        List<List<Integer>> result = threeSum(arr);

        out.write(result.toString());
        out.flush();
        out.close();
    }

    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);

        //如果数组元素小于三或者第一元素大于0又或者最后元素小于0
        if (nums.length < 3 || nums[0] > 0 || nums[nums.length - 1] < 0)
            return result;

        //首尾相等，所以全0
        if (nums[0] == 0 && nums[nums.length - 1] == 0){
            result.add(Arrays.asList(0, 0, 0));
            return result;
        }

        //使用双指针法， 一个指针指向左边界（i的下一位），一个指针指向右边界
        //如果 sum > 0 则右边界左移，sum < 0 则左边界右移
        for (int i = 0; i < nums.length; i ++) {

            //i判重
            //为什么不写nums[i] == nums[i + 1]呢
            //因为nums[i + 1] = left 我们定义的时候nums[i]跟Left其实是本质不同的两个数
            if (i > 0 && nums[i] == nums[i - 1])
                continue;


            //如果三个数中最小值大于0 则后面都不可能等于0
            if (nums[i] > 0)
                return result;

            int left = i + 1;
            int right = nums.length - 1;
            while(left < right) {

                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0)
                    right --; //由于sum太大，所以右边界指针左移
                else if (sum < 0)
                    left ++;  //由于sum太小，所以左边界指针右移
                else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));

                    //左边界指针left 右边界指针right 判重
                    while(left < right && nums[left] == nums[left + 1])
                        left ++;
                    while(left < right && nums[right] == nums[right - 1])
                        right --;

                    left ++;
                    right --;
                }
            }
        }
        return result;
    }
}

最后一道坚持一下！！！！

leetcode18.四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

答案中不可以包含重复的四元组。

示例1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

思路：
这道题跟第三题有点相似，但是要注意剪枝，给我剪了8个WA。。。
主要就还是在for循环外面再套一层for循环

---

答案：

public class test04 {

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {

        //读入一行，并按照空格拆分
        String[] arr = in.readLine().split(",");
        int[] nums = new int[arr.length];
        for (int i = 0; i < nums.length; i ++)
            nums[i] = Integer.parseInt(arr[i]);

        int target = Integer.parseInt(in.readLine());

        List<List<Integer>> result = fourSum(nums, target);

        out.write(result.toString());
        out.flush();
        out.close();
    }

    public static List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);

        /*
        这里错了！！！！  因为负数相加更小，所以我们不能以nums[0]>target作为剪枝
        //跟前面第三题一样，如果没有四个数，或者数组中最小数大于target
        if (nums.length < 4 || nums[0] > target)
            return result;
*/
        //一样使用双指针法，就是在第三题的情况下再外面再套一层for循环(最极限的情况下保证还有三个数给其余三个数用)
        for (int i = 0; i < nums.length - 3; i ++) {


            //因为只有当nums[i]大于0判断才有用，不然当nums[i] target均为负数时判断不准确
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }

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

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

                //j判重
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }

                int left = j + 1;
                int 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 {
                        result.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 result;
    }
}

自我总结

越学越觉得算法的奇妙，特别是双指针， 而且哈希表也挺好玩的
要记住想在一个集合中快速查找到一个元素，用哈希表准没错！！
朋友仍需努力 一起加油
兄弟萌冲啊！

大概就是这样，大家懂了吗 有什么不懂的评论区评论或者私信我吧！！