力扣算法：454.四数相加|| 383.赎金信 15.三数之和 18.四数之和

已于 2022-10-27 00:14:09 修改
阅读量664 收藏
点赞数
文章标签： 算法 leetcode 数据结构
于 2022-09-27 23:55:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51982291/article/details/127079971
版权

学习内容

力扣算法：

454.四数相加||

383.赎金信

15.三数之和

18.四数之和

具体内容

454.四数相加||

给你四个整数数组 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

提示：

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

454.四数相加->题目地址

做题思路

由于求得的元组是可重复的，因此思路与“两数之和”类似，先用hashmap获取前两个数组不同位置分别相加得到的值temp，再用0-temp判断后面两个数组不同位置分别相加是否有相对应的值；且由于返回元组个数，因此可以将前两个数组的值temp当作key，而相加得到的值temp在数组的次数当作value

解题

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    	HashMap<Integer,Integer> map = new HashMap<>();
    	for(int i:nums1){
    		for(int j:nums2){
    			int temp = i+j;
    			if(map.containsKey(temp)){
    				map.put(temp,map.get(temp)+1);
    			}else{
    				map.put(temp,1);
    			}
    		}
    	}
    	//该变量返回的元组个数
    	int res = 0;
    	for(int i:nums3){
    		for(int j:nums4){
    			int temp = i+j;
    			if(map.containsKey(0-temp)){
    				res += map.get(0-temp);
    			}
    		}
    	}
    	return res;
    }
 }

解答代码存在的疑问

1、为什么不是直接返回map的key值对应的value，而是需要把满足的条件的value相加
因为有4个数相加，他的排列方式肯定不值一种，而我们需要把满足条件的每一种出现的次数进行相加，最终才能得到所有的元素

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 由小写英文字母组成

383.赎金信->题目地址

做题思路

此题类似于“有效的字母异位词”，且有题目可得，ransomNote长度比magazine小且由magazine的元素组成，仍然可采用ASC||26为编码的思路，判断ransomNote每个字符出现的次数的是否小于magazine每个字符的次数

解题

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int res[] = new int[26];
        for(int i = 0;i < magazine.length();i++){
        	res[magazine.charAt(i)-'a']++;
	    }
	    for(int j = 0;j < ransomNote.length();j++){
	    	res[ransomNote.charAt(j)-'a']--;
	    }
	    for(int i:res){
			if(i < 0){
				return false;
			}
	    }
	    return true;
	}
}
解答代码存在的疑问

1、为什么当存放的数组元素比0时，说明ransomNote有字符是没有在magazine里面？
一开始元素都为0，后面对magazine进行操作，则对于其字符都会+1，而后对ransomNote进行操作，对ransomNote出现的字符则进行-1，因此要是字符在ransomNote出现而magezine不出现则数组里的对应的元素会变成比0小的数

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 。

提示：

3 <= nums.length <= 3000
-105 <= nums[i] <= 105

15.三数之和 -> 题目地址

做题思路

1、一开始想的是用哈希解法，两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在数组里出现过，但题目要求不可以包含重复的三元组，而若是把符合条件的三元组放进数组中在进行去重，则会过于复杂
2、使用双指针，这样就有利于我们不会取到重复的数值

解题

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        //使用双指针必须是有序的
        Arrays.sort(nums);
        //将i值看作第一个数，left和right分别看出第二个和第三个
        for(int i = 0;i < nums.length;i++){
        	//剪枝：由于前面已排好序，因此若是第一个元素大于0，后面的元素就都大于0
        	if(nums[i] > 0){
        		return list;
        	}
        	//去重，当前值与上一个值比较，i>0
        	if(i > 0 && nums[i] == nums[i-1]){
        		continue;
        	}
        	int left = i+1;
        	int right = nums.length-1;
        	//不能是left <= right的原因，若是相等，则元素重复，不符合题意
        	while(left<right){
        		if(nums[i] + nums[left] + nums[right] == 0){
        			list.add(Arrays.asList(nums[i],nums[left],nums[right]));
        			//去重
        			while(right > left && nums[left] == nums[left+1]){
        				left++;
        			}
        			while(right > left && nums[right] == nums[right-1]){
        				right--;
        			}
        			right--;
        			left++;
        		}else if(nums[i] + nums[left] + nums[right] > 0){
        			right--;
        		}else{
        			left++;
        		}
        	}
       }
       return list;
   }
}

解答代码存在的疑问

1、对第一个元素第一次去重的理解：
对第一个元素第一次去重的理解

2、对第二、三个元素第二次去重的理解：
对第二、三个元素第二次去重

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

18.四数之和 -> 题目地址

做题思路

与上述三数之和解法一致，但要注意是四个数字，有两次循环，以及题目给定了target值，因此剪枝的处理和上述不同

解题

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
    	ArrayList<List<Integer>> list = new ArrayList<>();
    	Arrays.sort(list);
    	for(int i = 0;i < nums.length;i++){
    		//剪枝处理：由于是给定的target，并不知晓是负数还是正数，因此要判断第一个元素大于0而直接返回链表，则要保证第一个元素在大于0的前提下还要大于target
    		if(nums[i] > 0 && nums[i] > target) {
    			return list;
    		}
    		//去重
    		if(i > 0 && nums[i] == nums[i-1]){
    			continue;
    		}
    		for(int j = i+1; j < nums.length;j++){
    			//去重
    			if(j > i+1 && nums[j] == nums[j-1]){
    				continue;
    			}
    			int left = j+1;
    			int right = nums.length - 1;
    			while(right>left){
                    if(nums[i]+nums[j]+nums[left]+nums[right] == target){
                        list.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        while(left < right && nums[left] == nums[left+1]){
                            right--;
                        }
                        left++;
                        right--;
                    }else if(nums[i]+nums[j]+nums[left]+nums[right] < target){
                        left++;
                    }else if(nums[i]+nums[j]+nums[left]+nums[right] > target){
                        right--;
                    }
                }
            }
        }
        return list;
    }
 }

解答代码存在的疑问

1、剪枝为什么要存在nums[i] > 0 的情况
这保证整条链表都是正数，且第一个就可以与target进行比较，若存在负数，这无法比较

复习

454.四数相加||

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int result = 0
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < nums1.length;i++){
            for(int j = 0; j < nums2.length;j++){
                int temp = nums1[i] + nums2[j];
                if(map.containsKey(temp)){
                    map.put(temp,map.get(temp)+1);
                }
                map.put(temp,1);
            }
        }
        for(int k = 0;k < nums3.length;k++){
            for(int l = 0;l < nums4.length;l++){
                int cur = nums3[k] + nums4[l];
                if(map.containsKey(0-cur)){
                    result += map.get(0-cur);
                }
            }
        }
        return result;
    }
}

383.赎金信

按字母异位词的思路解题

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

15.三数之和

考虑用set 但要求返回list

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Set<Integer> set = new Set<Integer>();
        List<Set<Integer>> list = new ArrayList<>();
        HashMap<Integer,Integer> map =new HashMap<>();
        for(int k = 0; k < nums.length;k++){
            map.put(nums[k],k);
        }
        for(int i:nums){
            for(int j:nums){
                int temp = i + j;
                if(map.containsKey(0-temp)){
                    set.add(i);
                    set.add(j);
                    set.add(0-temp);
                    list.add(set);
                }
            }
        }
    }
}

矫正

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        //使用双指针必须是有序的
        Arrays.sort(nums);
        //将i值看作第一个数，left和right分别看出第二个和第三个
        for(int i = 0;i < nums.length;i++){
        	//剪枝：由于前面已排好序，因此若是第一个元素大于0，后面的元素就都大于0
        	if(nums[i] > 0){
        		return list;
        	}
        	//去重，当前值与上一个值比较，i>0
        	if(i > 0 && nums[i] == nums[i-1]){
        		continue;
        	}
        	int left = i+1;
        	int right = nums.length-1;
        	//不能是left <= right的原因，若是相等，则元素重复，不符合题意
        	while(left<right){
        		if(nums[i] + nums[left] + nums[right] == 0){
        			list.add(Arrays.asList(nums[i],nums[left],nums[right]));
        			//去重
        			while(right > left && nums[left] == nums[left+1]){
        				left++;
        			}
        			while(right > left && nums[right] == nums[right-1]){
        				right--;
        			}
        			right--;
        			left++;
        		}else if(nums[i] + nums[left] + nums[right] > 0){
        			right--;
        		}else{
        			left++;
        		}
        	}
       }
       return list;
   }
}

18.四数之和

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
    	ArrayList<List<Integer>> list = new ArrayList<>();
    	Arrays.sort(list);
    	for(int i = 0;i < nums.length;i++){
    		//剪枝处理：由于是给定的target，并不知晓是负数还是正数，因此要判断第一个元素大于0而直接返回链表，则要保证第一个元素在大于0的前提下还要大于target
    		if(nums[i] > 0 && nums[i] > target) {
    			return list;
    		}
    		//去重
    		if(i > 0 && nums[i] == nums[i-1]){
    			continue;
    		}
    		for(int j = i+1; j < nums.length;j++){
    			//去重
    			if(j > i+1 && nums[j] == nums[j-1]){
    				continue;
    			}
    			int left = j+1;
    			int right = nums.length - 1;
    			while(right>left){
                    if(nums[i]+nums[j]+nums[left]+nums[right] == target){
                        list.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        while(left < right && nums[left] == nums[left+1]){
                            right--;
                        }
                        left++;
                        right--;
                    }else if(nums[i]+nums[j]+nums[left]+nums[right] < target){
                        left++;
                    }else if(nums[i]+nums[j]+nums[left]+nums[right] > target){
                        right--;
                    }
                }
            }
        }
        return list;
    }
 }
菜菜要要努力
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手绘算法力扣 1 两数之和(Two Sum)
07-27
手绘算法力扣 1 两数之和(Two Sum)
数据结构，力扣算法题.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
力扣练习第七天 ：454.四数相加||、383.赎金信、15.三数之和、18.四数之和
lsp_dd的博客
09-27 259
454.四数相加||、383.赎金信、15.三数之和、18.四数之和 哈希 双指针
力扣 | 哈希表2 | 454.四数相加||，383.赎金信，15.三数之和，18.四数之和
weixin_65736595的博客
02-07 960
一刷思路，难点，解决办法及详细含注释代码记录
LeetCode | 454.四数相加、383.赎金信、15.三数之和、18.四数之和
qq_73291520的博客
02-05 686
【代码】LeetCode | 454.四数相加、383.赎金信、15.三数之和、18.四数之和。
LeetCode：454.四数相加ll && 383.赎金信 && 15.三数之和 && 18.四数之和
weixin_47957908的博客
04-12 65
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!= k ，同时还满足 nums[i] + nums[j] + nums[k] == 0。将4个数组分成两个大数组，1和2 && 3和4，通过nums1和nums2的每一种和值，去对照nums3和nums4的值，产生1和2 && 3和4之间的对应值，通过键值对的方式，获取value并进行消除运算。链接：https://leetcode.cn/problems/3sum。
代码随想录算法训练营打卡第7天|454.四数相加||，383.赎金信，15.三数之和，18.四数之和
m0_61517193的博客
02-21 69
代码随想录算法训练营打卡第7天
代码随想录算法训练营DAY7| C++哈希表Part.2|LeetCode:454.四数相加II、383.赎金信、15. 三数之和、18.四数之和
糖炒栗子
03-26 1046
还记得四数相加II吗？建议去复习一下两个题目的不同点。想一想为什么四数之和要更难。还记得三数之和吗？方法上面有一些什么区别？其实和三数之和本质上是一样一样的。只不过我们在三数一和外面再套上一层循环罢了，这样可以想出代码逻辑。k从index = 0开始;i从index = 1开始;那么left从index = 2right从开始；如下图所示方框中就是套的三数之和的代码。但是这里有两个主要细节和难点。
算法训练DAY 7|力扣454.四数相加&&力扣383.赎金信&&力扣15.三数之和&&力扣18.四数之和
Syhaun的博客
05-17 87
今天做的都感觉很难，一方面，对Java是不特别熟悉，map和set的创建和使用不会，三数之和 四数之和弄懂了思路，代码照着敲的，对一些具体的细节实现，比如去重，不是很明白，有空一定2刷；
【力扣一轮】454.四数之和 && 383.赎金信
诚
05-22 499
为什么能想到这里，注意到它的和是0，（和可以是任何数）这样就相当于两两数组为一对，看其中一对数组中的元素，在另外一对数组中是否出现了相反数。这里的一对说的是A+B或其他组合方式，（不重要，因为都是随机的）然而以上想法截止到第二句，都没问题，需要注意的是，不是全对应。A2：因为在存储时，不仅要存储对应的元素，也要存储元素出现的次数，所以用到map。结合之前的有效字母异位符，数组，set，map，使用数组即可。也就是说如果一对数组中有两个-2，另一对数组中只有一个2，那么计算为0的次数为2。
代码随想录算法训练营day7| 454.四数相加 II 383.赎金信 15.三数之和
qq_62455003的博客
01-31 630
这道题的思路可以参照二数之和的思路，不过这道题需要先把两个数组的加和作为一组，另外两个数组的加和作为一组，再参照两数之和的思路。这道题的难度并不大，题意是说能不能使用杂志里面的字符来组成赎金信，其实就是想知道A字符串的字符是否都在B字符串中都出现过。进行数组遍历，i从下标0的地方开始，同时下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。就说明 此时三数之和大了，因为数组已经排过序，所以right–，使得三数之和变小。就说明 此时三数之和小了，所以left++，使得三数之和变大。
力扣：15三数之和（python）（csdn）————程序.pdf
12-05
力扣：15三数之和（python）（csdn）————程序
力扣算法思维导图.emmx
08-04
导图内容看这里: https://blog.csdn.net/weixin_43959833/article/details/119389231 导图里面有群号, 添加后会不断更新导图, 提供永久更新服务,用mindmaster打开导图
18 真题案例（三）：力扣真题训练.mp4
05-30
18 真题案例（三）：力扣真题训练.mp4
36. Adam 算法详解
qq_41238579的博客
07-10 946
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 58
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 181
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 61
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
力扣2. 两数相加 C++代码
05-25
下面是 C++ 的代码实现，使用链表来存储数字，从低位到高位依次相加，注意进位和边界情况的处理： ```c++ class Solution { public: ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode* dummy = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值