代码随想录算第7天 | 哈希表part02

TechyUnique

已于 2023-11-15 22:53:30 修改

阅读量85

点赞数

文章标签：散列表算法 leetcode

于 2023-11-15 22:45:58 首次发布

本文链接：https://blog.csdn.net/techy649/article/details/134431230

版权

代码随想录算法训练营第7天 | 哈希表part02 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

题目一 454.四数相加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 。

本题思路大致与上题相似，不过第一次需要提取数组a与b之和，之后对c与d再求和；将四个数组转换为两个数组后使用上一题的套路解决。

Java中Map.getOrDefault(Object key, V defaultValue)方法的作用是：
getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值defaultvalue。
例如map.getOrDefault(sum,0)+1 表示如果sum有对应的value值，就让value值加一；如果找不到sum,就返回默认值0并加一。

import java.util.HashMap;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer,Integer> newmap = new HashMap<>();
        int n = nums1.length;
        
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                int sum = nums1[i]+nums2[j];
                newmap.put( sum, newmap.getOrDefault(sum, 0)+1 );
            }
        }
        
        int count = 0;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                count += newmap.getOrDefault( 0 - nums3[i] - nums4[j] , 0);
            }
        }
        return count;

    }
}

代码的时间复杂度和空间复杂度都是 $O(n^2)$ 。- 最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2。

第一个for循环对nums1和nums2进行双层遍历，而第二个是对nums3和nums4进行遍历。
sum为key值，储存两个数组的和，value值为这些和出现的次数。
之后的count是计算四个数组和为0的次数。
实际上用for-each循环会更简洁。

题目二 383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：后者每个字符串只能使用一次，那么一旦ransom长于magazine，可直接返回false。

本题无大小写字符区别，所以可以使用数组做哈希表。
对两个字符串的比较可以用先加后减计数，先对第二个字符串各频率计数增加，后对第一个字符串计数减少。
最后结果如果为0就证明相同，为负就证明第一个字符串存在第二个字符串不存在的字符。(上面已经排除了为正的情况了)

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

        for(int k : arr)
        {
            if(k < 0)
            {
                return false;
            }
        }return true;
    }
}

题目三 15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
(不允许完全相同的组合，但元组内可以有相同数字。比如结果里有【1,2,-3】就不能再有【2,-3,1】)
示例：给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1],[-1, -1, 2] ]

首先可以使用哈希法实现，但是在剔除重复三元组方面困难重重，需要讨论的东西很多。
首先需要对数组进行排序。java可以使用Array类的sort方法。

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时非常的好用.
Arrays.sort(int[] a) :这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
                continue;
            }
            unordered_set<int> set;
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2
                        && nums[j] == nums[j-1]
                        && nums[j-1] == nums[j-2]) { // 三元组元素b去重
                    continue;
                }
                int c = 0 - (nums[i] + nums[j]);
                if (set.find(c) != set.end()) {
                    result.push_back({nums[i], nums[j], c});
                    set.erase(c);// 三元组元素c去重
                } else {
                    set.insert(nums[j]);
                }
            }
        }
        return result;
    }
};

而使用双指针法比哈希法更高效一些。先将数组排序，之后在整个数组中寻找三个数之和为0，根据三个数总和的正负性不断调整左右两个指针，直到最终和为0.
在数组中找到 abc 使得a + b +c =0，相当于 a = nums[i]，b = nums[left]，c = nums[right]。
使用一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
接下来移动left 和right，因为i是每轮才移动的所以当轮不能动。
如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组从大到小排序，所以right下标就应该向左移动，减小正的部分，才能让三数之和小一些。
如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，减小负的部分，才能让三数之和大一些，直到left与right相遇为止。

关键点在于去除重复的部分。

如果b,c重复了a，那么只需跳过当轮循环(nums[i])。
但这里有一个问题.对a是判断 nums[i] 与 nums[i + 1]相同，还是判断 nums[i] 与 nums[i-1] 相同?

这两个不一样！也就是和 nums[i]进行比较，是比较它的前一个，还是比较它的后一个。
如果我们的写法是与后一个比较：

if (nums[i] == nums[i + 1]) { // 去重操作
    continue;
}

那我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断下一个也是-1，那这组数据就pass了。
应当不能有重复的三元组，但三元组内的元素是可以重复的！

那么应该这么写：

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

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到结果集里。
之所以让a大于0，是因为a,b,c 只会有负，正，正或者负，负，正或者负，0，正或者全0 的情况。而上面代码会continue的情况不涉及以上情况，从而不会漏掉情况。

之后是对b与c的比较。
因为是三个数，所以left和right不能指向同一位置，即条件为right>left。
如果和大于0就 right–; 和小于0就 left++;
相等时就将结果放入二维数组中。

对b和c的去重：只有如下可能：b和c的邻近区域内都是和b、c相等的数，且满足b<c.
(如：0 -1 -1 -1 -1 1 1 1 1)
因此只要比较left右侧、right左侧的数是否与它们本身相等即可，用while跳过所有相等的可能到达终点，之后退出循环。

完全被血虐，还是看参考吧…

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
	// 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.length; i++) {
	    // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) { 
                return result;
            }
			//a的去重
            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;
            //关键在这，b与c的比较和去重
            while (right > left) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
		    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) 
	                    right--;
                    while (right > left && nums[left] == nums[left + 1])
	                     left++;
                    //让left和right跳过所有相等的结果直接相撞
                    right--; 
                    left++;
                }
            }
        }
        return result;
    }
}

题目四 18. 四数之和

题意：给定一个包含 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] ]

方法和上面的三数相加类似，保证双指针left和right在最内侧，外侧依次循环套层，然后针对情况剪枝。三数相加时间复杂度为O(n^2), 四数相加时间复杂度为 $O(n^3)$ ，以此类推。
注意left开始的位置，和内侧遍历循环开始的位置是外侧循环的起点之后，即i+1和k+1.

题解如下。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        int length = nums.length;
        for(int i=0; i<length; i++)
        {
            //剪枝
            if(nums[i] > target && nums[i] >0)
            {
                return ans;
            }
            if( i>0 && nums[i] == nums[i-1] )
            {
                continue;
            }
            //二级剪枝
            for(int k= i+1; k<length; k++)
            {
                if(k > i+1 && nums[k] == nums[k-1])
                {
                    continue;
                }

                int left = k + 1;
                int right = length - 1;
                while(right > left)
                {
                    int sum = nums[i]+ nums[k] + nums[left] + nums[right];
                    if(sum > target)
                    {
                        right--;
                    }else if(sum < target)
                    {
                        left++;
                    }else{
                        ans.add( Arrays.asList(nums[i],nums[k],nums[left], nums[right]));
                        while(right > left && nums[right] == nums[right-1])
                            right--;
                        while(right > left && nums[left] == nums[left+1] )
                            left++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return ans;
    }
}