454.四数相加II
给你四个整数数组 nums1
、nums2
、nums3
和 nums4
,数组长度都是 n
,请你计算有多少个元组 (i, j, k, l)
能满足:
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 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
思路
- 题中四个数组,长度一样,每个数组任选一个组成和为0的四元组,可以两两相加,转换为两数之和问题
- 数组中有重复的元素,每个元素只能用一次,所有元组的数量相当于要对每个数组做笛卡尔积,求出总数
- 元祖内只要不是同一个索引的值,就认为不是重复元组
复杂度
- 时间 O(n^2)
- 空间 O(n)
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0 ;
//key-两个数组中出现的数值,value-和出现的次数
Map<Integer,Integer> sum1 = new HashMap<Integer,Integer>();
Map<Integer,Integer> sum2 = new HashMap<Integer,Integer>();
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
int s1 = nums1[i] + nums2[j];
sum1.put(s1,sum1.getOrDefault(s1,0)+1);
int s2 = nums3[i] + [j];
sum2.put(s2,sum2.getOrDefault(s2,0)+1);
}
}
for(int i : sum1.keySet()){
if(sum2.containsKey(0-i)){
res += sum2.get(0-i) * sum1.get(i);
}
}
return res ;
}
}
未优化版
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
//两两数组结合,做笛卡尔积得到两个相加后的大小为n*n的数组,将问题转化为两数之和
int n = nums1.length ,r = 0 ;
Map<Integer,Integer> m1 = mergeSum(nums1,nums2);
Map<Integer,Integer> m2 = mergeSum(nums3,nums4);
for(int v : m1.keySet()){
if(m2.containsKey(0 - v )){
r += m1.get(v) * m2.get(0-v);
}
}
return r ;
}
public Map<Integer,Integer> mergeSum(int[] n1 ,int[] n2){
//任意两个数组元素和为key,value为和出现的次数,代表不同元祖
Map<Integer,Integer> res = new HashMap<Integer,Integer>();
int pos = 0 ;
for (int i = 0; i < n1.length; i++) {
int v1 = n1[i];
for (int j = 0; j < n2.length; j++) {
int v2 = n2[j];
res.put(v1+v2,res.getOrDefault(v1+v2,0)+1);
}
}
return res ;
}
}
383. 赎金信
给你两个字符串:ransomNote
和 magazine
,判断 ransomNote
能不能由 magazine
里面的字符构成。
如果可以,返回 true
;否则返回 false
。
magazine
中的每个字符只能在 ransomNote
中使用一次。
示例 1:
输入:ransomNote = "a", magazine = "b"
输出:false
示例 2:
输入:ransomNote = "aa", magazine = "ab"
输出:false
示例 3:
输入:ransomNote = "aa", magazine = "aab"
输出:true
提示:
1 <= ransomNote.length, magazine.length <= 105
ransomNote 和 magazine 由小写英文字母组成
思考
- 解法同“有效异构词”,区别在于数组最终的值中是否有大于0数值
- 字符由小写字母构成,可用数组代替hash表
复杂度
- 时间 O(n)
- 空间 O(1)
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
int[] words = new int[26];
for (int i = 0; i < ransomNote.length(); i++) {
words[ransomNote.charAt(i) - 'a']++ ;
}
for (int i = 0; i < magazine.length(); i++) {
words[magazine.charAt(i) - 'a']--;
}
for (int i = 0; i < words.length; i++) {
//说明有字符未被包含
if(words[i] > 0){
return false;
}
}
return true;
}
}
15.三数之和
给你一个整数数组 nums
,判断是否存在三元组 [nums[i], nums[j], nums[k]]
满足 i != j
、i != k
且 j != k
,同时还满足 nums[i] + nums[j] + nums[k] == 0
。请
你返回所有和为 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 。
思考(双指针)
- hash表转换为两数之和,不能解决重复问题,此处可固定一个数,使用双指针思想
- 滑动窗口+双指针需要数组是排序递增的
- 重复元组去重,前后元素不能相同,在每个指针移动(包括固定值i)的时候要和前一个元素做判断是否相同,相同的话需要跳过,达到去重目的
复杂度
- 时间 O(n^2)
- 空间 O(n)
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
if (nums[i] > 0) {
//排序后,右边的肯定大于0,不符合条件
return res;
}
//判断i位置的重复元素
if (i>0 && nums[i] == nums[i-1]) {
continue;
}
//固定i,转化为两数之和,排序数组可用双指针
int l = i + 1, r = nums.length - 1;
while (l < r) {
int sum = nums[i] + nums[l] + nums[r];
System.out.println("sum:" + sum);
if (sum > 0) {
--r;
} else if (sum < 0) {
++l;
} else {
res.add(Arrays.asList(nums[i], nums[l], nums[r]));
//第二位去重
while (l<r && nums[r] == nums[r-1]) {
--r;
}
//第三位去重
while (l<r && nums[l] == nums[l+1]) {
++r;
}
++l;
--r;
}
}
}
return res;
}
}
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
你可以按 任意顺序 返回答案 。
示例 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]]
提示:
1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109
思考
-
思想同“三数之和”
-
固定的前两个值,都需要剪枝判断,避免重复
-
注:固定值大于0 且 目标值target要大于0时才剪枝,反之和肯定越来越小,不需要剪枝
-
时间 O(n^3)
-
空间 O(n)
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
//固定第一个数
if(nums[i] >= target) return res;
//去重1
if(i>0 && nums[i] == nums[i-1]) continue;
for (int j = i+1; j < nums.length; j++) {
//固定第二个数
//此处的剪枝,需要判断大于0的情况,避免targe为负数,导致多剪了,元素大于0的可以直接剪掉
if(nums[i] + nums[j] >= target && nums[i]>0 && nums[j] >0) return res;
//去重2
if(j>(i+1) && nums[j] == nums[j-1]) continue;
//双指针移动,判断后两个元素
int l = j+1 , r = nums.length -1 ;
while(l<r){
int sum = nums[i] + nums[j] + nums[l] + nums[r] ;
if(sum > target){
--r;
}else if(sum < target){
++l;
}else{
res.add(Arrays.asList(nums[i],nums[j],nums[l],nums[r]));
//去重3
while(l<r && nums[r] == nums[r-1]){
--r;
}
//去重4
while(l<r && nums[l] == nums[l+1]){
++l;
}
++l;
--r;
}
}
}
}
return res ;
}
}
总结
- 判断数值是否存在试用hash表,元素范围固定试用数组代替hash表
- 三数之和、四数之和试用双指针+滑动窗口思想,更方便去重操作;(先排序)