1.454.四数相加II（难度：中等；耗时：40min；解题思路：hash中的map）
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
输入：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
# 使用到的数据结构，下次可能还会忘掉的：
1)：Map<Integer, Integer> map = new HashMap<Integer,Integer>();
2)：map.keySet();
3): map.containsKey();
4): map.get();
代码：我自己写的，属于是特别繁琐，中间使用的某些数据结构还是对着chatgpt查阅的。
解法一：
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map1 = new HashMap<Integer, Integer>();
Map<Integer, Integer> map2 = new HashMap<Integer, Integer>();
int m = 0;
for(int i = 0; i < nums1.length; i++){
for(int j = 0; j < nums2.length; j++){
map1.put(nums1[i] + nums2[j], map1.getOrDefault(nums1[i] + nums2[j], 0) + 1);
m++;
}
}
int n = 0;
for(int i = 0; i < nums3.length; i++){
for(int j = 0; j < nums4.length; j++){
map2.put(nums3[i] + nums4[j], map2.getOrDefault(nums3[i] + nums4[j], 0) + 1);
n++;
}
}
int sum = 0;
for(Integer x : map1.keySet()){
if(map2.containsKey(-x)){
sum += map1.get(x) * map2.get(-x);
}
}
return sum;
}
}
解法2：其实这个是和解法1一样的，但是是只使用了一个map，减少了空间消耗，还是我自己写的,记住数据结构后再写这道题很快，10min不到就写完了。
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
int m = 0;
for(int x : nums1){
for(int y : nums2){
map.put(x + y, map.getOrDefault(x + y, 0) + 1);
}
}
int count = 0;
for(int x : nums3){
for(int y : nums4){
if(map.containsKey(- x - y)){
count += map.get(-x - y);
}
}
}
return count;
}
}
2.383.赎金信件（难度：简单；耗时：20min；解法：哈希map；）
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。
输入：ransomNote = "a", magazine = "b"
输出：false
# 使用到的方法
map.getOrDefault();
magazine.toCharArray();
map.put();
map.values()
解法：20min秒了，就是里面的数据结构还是不太熟悉，所以对着chatgpt改正了一下，和上面的数据结构差不多。
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
Map<Character, Integer> map = new HashMap<Character, Integer>();
for(char x : magazine.toCharArray()){
map.put(x, map.getOrDefault(x, 0) + 1);
}
for(char y : ransomNote.toCharArray()){
if(map.containsKey(y)){
map.put(y, map.get(y) - 1);
}else{
map.put(y, map.getOrDefault(y, 0) - 1);
}
}
for(int x : map.values()){
if(x < 0) return false;
}
return true;
}
}
# 解释一下，这个解题思想是这样的，
1）：将magazine和ransomNote中的String使用toCharArray()转换成单个的char，然后将magazine中的char存放到map中，map的键是对应的char，值是这个char出现的次数。
2）：然后再将ransomNote中的char存放到map中，当ransomNote中的char和map中的char相同时，就将map中这个char对应的值减1。如果map中这个char对应的值小于0时，就证明ransomNote中这个char的数量多于magazine中这个值的数量，然后就返回false;
3）：ransomNote中的char不存在map中，那么就将这个char对应的值从0减一。
4）：判断map中char对应的值是否为负值，是负数就返回false；
解法二：代码随想录的数组hash解法,很明显比我写的要简单好多，但是上面是我自己写的。
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
if (ransomNote.length() > magazine.length()) {
return false;
}
int[] record = new int[26];
for(char c : magazine.toCharArray()){
record[c - 'a'] += 1;
}
for(char c : ransomNote.toCharArray()){
record[c - 'a'] -= 1;
}
for(int i : record){
if(i < 0){
return false;
}
}
return true;
}
}
3.15.三数之和(难度：中等；耗时：30min；解法：双指针；)
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
输入：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] 。
注意，输出的顺序和三元组的顺序并不重要。
代码：我自己写的，然后参照了一下代码随想录，然后这道题大约25min完成的，下面会写出对应的解题思路和关键代码的解释。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for(int i = 0; i < nums.length; i++){
int left = i + 1;
int right = nums.length - 1;
if(i > 0 && (nums[i] == nums[i - 1])){
continue;
}
while(left < right){
if(nums[i] + nums[left] + nums[right] == 0){
List<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
else if(nums[i] + nums[left] + nums[right] < 0){
left++;
}else{
right--;
}
}
}
return result;
}
}
# 关键代码1：
if(i > 0 && (nums[i] == nums[i - 1])){
continue;
}
解释：这是针对nums[i]的去重，例如当出现[0,0,0,0]这样的情况时，如果不使用关键代码1，result中会存在[0,0,0]和[0,0,0]两个答案。
# 关键代码2：
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
解释：这是针对right和left的去重，然后去重完成后，right--；left++,进行下一个可能解的求解。
所以这个解题方法很简单，然后我打算计时写一遍。12min写完了，不过看了一个边界条件right > left。
4.18.四数之和（难度：中等；耗时：0Min；解法：双指针）
给你一个由 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
你可以按 任意顺序 返回答案 。
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
解法：真的累了，对着抄了一遍，具体的解法下次补上。
import java.util.*;
public class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
Arrays.sort(nums);
List<List<Integer>> result = new ArrayList<>();
for (int k = 0; k < nums.length; k++) {
if (nums[k] > target && nums[k] >= 0) {
break;
}
if (k > 0 && nums[k] == nums[k - 1]) {
continue;
}
for (int i = k + 1; i < nums.length; i++) {
if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
break;
}
if (i > k + 1 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (right > left) {
long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
if (sum > target) {
right--;
} else if (sum < target) {
left++;
} else {
result.add(Arrays.asList(nums[k], nums[i], 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 result;
}
public static void main(String[] args) {
Solution solution = new Solution();
int[] nums = {1, 0, -1, 0, -2, 2};
int target = 0;
List<List<Integer>> results = solution.fourSum(nums, target);
for (List<Integer> result : results) {
System.out.println(result);
}
}
}
扫一扫
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
