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

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

四数相加

给定四个包含整数的数组列表 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 。

例如:

输入:

• A = [ 1, 2]
• B = [-2,-1]
• C = [-1, 2]
• D = [ 0, 2]

输出:

2

解释:

两个元组如下:

1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

个人思路：

• 要计算四个数组各取一个数字相加，这里想到两两拆分排列组合
• 第二组求和的时候，我们需要去查找目标数有没有出现过，出现的次数，并累加出现的次数
• 由此想到使用HashMap，key为求和，value为出现次数

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> map = new HashMap<>();
        //key为前两个数组的排列组合sum，value为sum出现的次数
        int index = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                int sum = nums1[i] + nums2[j];
                if (map.containsKey(sum))
                    map.put(sum, map.get(sum) + 1);
                else map.put(sum, 1);
            }
        }
        for (int i = 0; i < nums3.length; i++) {
            for (int j = 0; j < nums4.length; j++) {
                int needSum = -1 * (nums3[i] + nums4[j]);
                index += (map.containsKey(needSum) ? map.get(needSum) : 0);
            }
        }
        return index;
    }
}

赎金信

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

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

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

个人思路：

• 使用两个map，存储两个字符串出现的字母和出现的次数
• 然后再比较出现的次数即可
• 注意比较的时候有个判断非空操作
• 可改进：只需要一个map，当遍历ransomNote字符串时，只需要–map中对应位置的value即可

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character, Integer> map1 = new HashMap<>();
        HashMap<Character, Integer> map2 = new HashMap<>();
        for (int i = 0; i < ransomNote.length(); i++) {
            char c = ransomNote.charAt(i);
            if (map1.containsKey(c))
                map1.put(c, map1.get(c) + 1);
            else map1.put(c, 1);
        }
        for (int i = 0; i < magazine.length(); i++) {
            char c = magazine.charAt(i);
            if (map2.containsKey(c))
                map2.put(c, map2.get(c) + 1);
            else map2.put(c, 1);
        }
        Set<Character> keySet = map1.keySet();
        for (Character c : keySet) {
            int num1 = map1.get(c);
            int num2 = map2.get(c) != null ? map2.get(c) : 0;
            if (num1 > num2)
                return false;
        }
        return true;
    }
}

题解解析：

• 法一：暴力枚举，不推荐
• 法二：哈希法
  • 只有小写字母，考虑使用数组，而不使用map
  • 因为使用map消耗较大，map要维护红黑树或哈希表，而且还有哈希函数，是费时的
  • 数据量小直接使用数组即可

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] map = new int[26];

        for (int i = 0; i < magazine.length(); i++) {
            map[magazine.charAt(i) - 'a']++;
        }
        for (int i = 0; i < ransomNote.length(); i++) {
            map[ransomNote.charAt(i) - 'a']--;
            if (map[ransomNote.charAt(i) - 'a'] < 0)
                return false;
        }
        return true;
    }
}

三数之和

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

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

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

个人思路：

• 考虑过使用哈希法，但涉及一个去重问题，并且复杂度较高
• 尝试使用双指针法，但各种情况不能考虑周到，最终未能解题

题解思路：

• 法一：哈希法（去重较为复杂，这里暂时不讨论，以后有时间再去了解

• 法二：双指针法（固定i，移动left、right两个指针）

  • 使用二维数组存储返回结果

  • 三个指针，如何不重复地移动判断呢？定1移2法

    • 固定i指针，移动left指针和right指针
    • 当sum < 0 时，right左移
    • sum > 0时，left右移
    • sum == 0，时存入数组（还要做去重操作）

  • 去重的思考（a,b,c三个数之和）

    • a的去重
      • 在进行移动i的循环过程中，如果i与前一个i相等，则跳过本层循环（nums[i] == nums[i - 1]）
      • 注意，不要混淆nums[i] == nums[i + 1]，这个代表含义是与后一个相等就跳过循环，遇到特殊情况会一直跳过，得不到正确答案
    • b、c的去重
      • bc的去重同样和a的类似，b判断下一个数是否相等，相等则继续右移，c同理左移
      • bc的去重要在存储了sum==0之后再进行，否则可能会出现sum==0的结果并未存储就一直移动指针到跳出循环

  • 一些其他的细节

    • 排序过后第一个数就大于0，直接返回结果集。这样就不必过于纠结循环退出条件了，必然在此提前退出

    • 去重操作不能用查找数组是否包含此结果来判断是否add，会超时

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] > 0)
                return lists;
            //去重a的操作
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum < 0)
                    left++;
                else if (sum > 0)
                    right--;
                else {
                    lists.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    //bc去重
                    while (left < right && nums[left] == nums[left + 1])
                        left++;
                    while (left < right && nums[right] == nums[right - 1])
                        right--;
                    left++;
                    right--;
                }
            }
        }
        return lists;
    }
}

四数之和

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

注意：

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

示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

个人思路：整体沿用上一题的思路

• 对比上一题，多了一个变量
• 多加一层循环，两层循环都要做一次去重操作，
• 注意一下b的去重中，要判断的是j > i+1;(即比第一个固定的数至少大2)

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums.length < 4)
            return result;
        Arrays.sort(nums);

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > target && nums[i] >= 0)  //此后的数不可能再满足要求，直接退出
                return result;
            if (i > 0 && nums[i] == nums[i - 1])  //a的去重
                continue;
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1])   //b的去重
                    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)
                        left++;
                    else if (sum > target)
                        right--;
                    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;
    }
}

题解解析：

• 本道题和三数之和都是类似的思路，通过双指针法，使得时间复杂度比暴力法降低了一个数量级
• 当遇到五数之和、六数之和，我们还是采取类似的思路
• 关键是做好各种去重的操作

总结

• 什么题目考虑使用哈希表

  • 判断元素是否出现过，或者出现过几次

• 哈希表常见的几种结构及选择

  • 数组：数据量少，数据区间小，例如全体小写字母的数据
  • set集合：数据量大，数据区间大，只需要知道元素出现过，不需要记录出现的次数
  • map集合：数据量大，数据区间大，需要同时记录元素出现及出现次数

• 数组作为哈希表

  • 242.有效的字母异位词
  • 383.赎金信

  不难发现，两道题都是26个字母，直接根据ASCII码差值即可存储到固定大小的数组中

• set作为哈希表

  • 349. 两个数组的交集 当这道题没有限制数值的大小就使用set
  • 202.快乐数

  使用set，不用数组：

  • 数组大小有限，容易受到系统栈（非数据结构的栈）的空间限制
  • 数组足够大，但哈希值排列稀疏、元素分数，造成空间大量浪费

• map作为哈希表

  • 1.两数之和
  • 454.四数相加

  两题都是需要记录数值及其出现次数，故考虑双列集合map

• 双指针法客串

  • 18. 四数之和
  • 15.三数之和

  三个指针：定1移2

  四个指针：定1定1移2

  … 实质都是通过循环+双指针实现复杂度相比于暴力法降低一个数量级的办法