第七天了 继续刷刷刷 去看看计网和操作系统
454.四数相加II
题目链接：454. 四数相加 II - 力扣（LeetCode）
题目讲解：代码随想录
完全不会 看代码随想录吧
思路：
- 首先定义 一个unordered_map key放a和b两数之和 value 放a和b两数之和出现的次数
- 遍历大A和大B数组 统计两个数组元素之和 和出现的次数 放到map中
- 定义int变量count 用来统计 a+b+c+d = 0 出现的次数
- 再遍历大C和大D数组 找到如果 0-(c+d) 在map中出现过的话 就用count把map中key对应的value也就是出现次数统计出来
- 最后返回统计值 count 就可以了（引用自代码随想录）
Java代码：
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0;
Map<Integer, Integer> map = new HashMap<>();
//统计两个数组中的元素和 同时统计出现次数 放入map
for(int i : nums1){
for(int j : nums2){
int sum = i + j;
map.put(sum, map.getOrDefault(sum , 0) + 1);
}
}
//统计剩余的两个元素和 在map中找是否存在相加为0的情况 同时记录次数
for(int i : nums3){
for(int j : nums4){
res += map.getOrDefault(0 - i - j, 0);
}
}
return res;
}
}
在Java代码里需要注意几个问题：
引用gpt的回答 getOrDefault 是 Map 接口的一个方法 它接受两个参数 一个是键（key）另一个是默认值（defaultValue）当使用 getOrDefault 方法从 Map 中检索值时 如果键存在于 Map 中 它将返回与该键关联的值 如果键不存在 则返回指定的默认值
对 res += map.getOrDefault(0 - i - j, 0)代码的解释：
- 计算
0 - i - j的值，即-i - j，这是第三个和第四个数组中的元素i和j的和的相反数。 - 使用这个值作为键去查询
map中是否存在对应的值。 - 如果
map中存在键为-i - j的项，则getOrDefault方法返回该键对应的值，这个值表示nums1和nums2中元素之和为-i - j的组合数量。 - 如果
map中不存在键为-i - j的项，则getOrDefault方法返回默认值0。 - 将得到的结果（无论是
map中的值还是默认值0）加到res变量上，res用于累计所有可能的四元组之和为0的组合数量。
383. 赎金信
讲解链接：代码随想录
给你两个字符串 a 和 b ，判断 a 能不能由 b 里面的字符构成
这道题目是求 字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a
题目很简单 思路也很清楚 那就开始写代码
Java代码：
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
//shortcut
if(ransomNote.length() > magazine.length()){
return false;
}
//定义一个哈希映射数组
int[] nums = new int[26];
//遍历数组
for(char c : magazine.toCharArray()){
nums[c - 'a'] += 1;
}
for(char c : ransomNote.toCharArray()){
nums[c - 'a'] -= 1;
}
//如果数组中存在负数 说明字符串a中存在字符串b中没有的字符
for(int i : nums){
if(i < 0){
return false;
}
}
return true;
}
}看起来很简单 实际上用了toCharArray()方法和 nums[c - 'a'] 的字符串表示 下标索引是a-z的26个字符 对应的value是该字符出现次数
15. 三数之和
讲解链接：代码随想录
看似很简单的难题哈 不会 看看代码随想录 给出的较优思路是双指针 看懂了确实很不错 还是先从最直接的基础版本开始 暴力一下 哈希一下 不过确实很麻烦
Java代码：
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList<>();
Arrays.sort(nums);
for(int i = 0; i < nums.length; i++){
//如果第一个元素大于0 不可能凑成三元组
if(nums[i] > 0){
return ans;
}
//三元组a元素取重
if(i > 0 && nums[i] == nums[i - 1]){
continue;
}
HashSet<Integer> set = new HashSet<>();
for(int j = i + 1; j < nums.length; j++){
//三元组b元素去重
if(j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]){
continue;
}
int c = -nums[i] - nums[j];
if(set.contains(c)){
ans.add(Arrays.asList(nums[i], nums[j], c));
set.remove(c);//三元组元素c去重
}else{
set.add(nums[j]);
}
}
}
return ans;
}
}//真的很麻烦 很复杂 不容易直接写错了 换个双指针15. 三数之和
讲解链接：代码随想录
看起来很麻烦 要求 a + b + c = 0的不重复三元组 有哈希解法和双指针解法 哈希不容易想但是双指针比较清晰
Java代码（哈希解法）：
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList<>();
Arrays.sort(nums);
for(int i = 0; i < nums.length; i++){
//如果第一个元素大于0 不可能凑成三元组
if(nums[i] > 0){
return ans;
}
//三元组a元素取重
if(i > 0 && nums[i] == nums[i - 1]){
continue;
}
HashSet<Integer> set = new HashSet<>();
for(int j = i + 1; j < nums.length; j++){
//三元组b元素去重
if(j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]){
continue;
}
// 我们只关心不重复的三元组，即每个三元组只能被计算一次。
// 由于nums数组已经排序，当我们向右移动j指针时，
// 不可能再找到与c相等的数（因为相等的数已经在HashSet中，
// 且nums[j]是递增的），所以移除c可以避免后续重复添加相同的三元组。
int c = -nums[i] - nums[j];
if(set.contains(c)){
ans.add(Arrays.asList(nums[i], nums[j], c));
set.remove(c);//三元组元素c去重
}else{
set.add(nums[j]);
}
}
}
return ans;
}
}//真的很麻烦 很复杂 不容易直接写错了 换个双指针双指针解法（推荐）：
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList<>();
Arrays.sort(nums);
//找出a + b + c = 0
//a = nums[i] b = nums[j] c = nums[right]
for(int i = 0; i < nums.length; i++){
//排序之后如果第一个元素已经大于0 那么无论如何组合都不可能凑成三元组
if(nums[i] > 0){
return ans;
}
if(i > 0 && nums[i] == nums[i - 1]){//去重a
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{
ans.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++;
right--;
left++;
//双指针确实好理解 也方便写也好看
}
}
}
return ans;
}
}18. 四数之和
讲解链接：代码随想录
题目描述：给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
wc 要求这么高 看代码随想录 写代码真有意思 多写写
Java代码：
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<>();
for(int k = 0; k < nums.length; k++){
//剪枝处理
if(nums[k] > target && nums[k] >= 0){
break;
}
//对nums[k]去重
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;
}
//对nums[i]去重
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{
ans.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
//对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;
}
}四数之和和三数之和一个思路 只是添加了一个数 时间复杂度变成O（n^3）
OK了 今天也是刷题的一天
扫一扫
1331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
