一、四数相加 II
力扣454
只统计有几个符合结果的四元组,不计较四元组是否重复。考虑使用hashmap存储前两个数组nums[i]与nums[j]之和sum = nums[i] + nums[j],key为sum,value为取得该值的sum出现的次数。再计算后两个数组nums[k]与nums[l]之和,看是否等于-sum如果等于-sum则说明存在一个四元组。
时间复杂度: O(n^2)
空间复杂度: O(n^2)
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
// 将nums[i] + nums[j]的值存进map中
for(int i : nums1){
for(int j : nums2){
int sum = i + j;
//map.put(sum, map.get(sum) + 1)
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
}
int result = 0;
//从map中找值为-(num3[i] + num[4])出现的次数
for(int i : nums3){
for(int j : nums4){
int sum = -(i + j);
result += map.getOrDefault(sum, 0);
}
}
return result;
}
}
二、赎金信
力扣383
首先判断ransomNote的长度,如果ransomNote的长度比magazine长的话那么ransomNote就无法由magazine一对一构成。然后将magzine的每个字母存到map中,key为magzine中的每个字符,value为该字符出现的次数。再遍历ransomNote,如果发现ransomNote中的字符在magzine中出现过,则令该字符(key)在magzine中对应的value值减一,如果对应的value值为0则说明magzine缺少该字符,返回false,这样在遍历完ransomNote后,返回true。
时间复杂度: O(n)
空间复杂度: O(1)
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
int[] alphabet = new int[26];
//如果ransomNote的长度比magazine长的话那么ransomNote就无法由magazine一对一构成
if(ransomNote.length() > magazine.length()){
return false;
}
char[] magletter = magazine.toCharArray();
for(int i = 0; i < magazine.length(); i++){
int cha = magletter[i] - 'a';
alphabet[cha] += 1;
}
char[] ranletter = ransomNote.toCharArray();
for(int i = 0; i < ransomNote.length(); i++){
int cha = ranletter[i] - 'a';
if(alphabet[cha] > 0){
alphabet[cha] -= 1;
}else{
return false;
}
}
return true;
}
}
三、三数之和
力扣15
双指针法,先对数组nums进行排序,然后遍历数组nums。取两个指针left = i+1、right = nums.length - 1,判断nums[i] + nums[left] + nums[right]的值与0的大小,如果大于0则令right--,否则令left++,注意在遍历过程中对i,j和k去重。
时间复杂度: O(n^2)
空间复杂度: O(1)
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
//排序
Arrays.sort(nums);
//排序之后如果第一个数大于0则无论如何都无法满足三元组之和等于0
if(nums[0] > 0){
return result;
}
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
//对i去重
if(i > 0 && nums[i] == nums[i-1]){
continue;
}
//双指针法
int left = i + 1;
int right = nums.length - 1;
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]));
//对j和k去重
while(right > left && nums[right] == nums[right - 1]){
right--;
}
while(right > left && nums[left] == nums[left + 1]){
left++;
}
right--;
left++;
}
}
}
return result;
}
}
四、四数之和
力扣18
与三数之和类似,要注意的一点是target可能是正也可能是负,只有当第一个数大于0且大于target的时候才会不满足四元数之和等于target,当target<0的时候直接开始计算即可。
时间复杂度: O(n^3)
空间复杂度: O(1)
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> result = new ArrayList<>();
//排序
Arrays.sort(nums);
//注意,只有当第一个数大于0且大于target的时候才会不满足四元数之和等于target,当target<0的时候直接开始计算即可
if(nums[0] > 0 && nums[0] > target){
return result;
}
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
//对a去重
if(i > 0 && nums[i] == nums[i-1]){
continue;
}
for(int j = i + 1; j < nums.length; j++){
//对b去重
if(j > i + 1 && nums[j - 1] == nums [j]){
continue;
}
//双指针法
int left = j + 1;
int right = nums.length - 1;
while(right > left){
long sum = (long)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]));
//对c和d去重
while(right > left && nums[right] == nums[right - 1]){
right--;
}
while(right > left && nums[left] == nums[left + 1]){
left++;
}
right--;
left++;
}
}
}
}
return result;
}
}