[LeetCode] 4Sum

最新推荐文章于 2020-10-05 14:16:33 发布
最新推荐文章于 2020-10-05 14:16:33 发布
阅读量548 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/erorr/article/details/24863469
版权

这个问题开始的思路还是对的，先求出任意两个数的和，保存这个值以及对应的加数的位置信息。复杂度为O(N^2)。

然后对这些和排序，复杂度估计就到了O(logN*(N^2))。

最后遍历这个序列，找出所有可能的值，暂不讨论这个复杂度。

尽管如此，还是经常超时，经过了一些细节的优化，才勉强通过。

不过通过测试，发现LeetCode对输出的结果的顺序可以匹配，另外这个题的超时时间大概是1s（Java）。

下面是第一个小板凳：

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
		ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
		if (num.length < 4) {
			return results;
		}
		int length = num.length;
		Set<Integer> sumsOfTwoNumber = new HashSet<Integer>();
		HashMap<Integer, ArrayList<ArrayList<Integer>>> mapForSums = new HashMap<Integer, ArrayList<ArrayList<Integer>>>();

		for (int i = 0; i < length; ++i) {
			int num1 = num[i];
			for (int j = i + 1; j < length; ++j) {
				Integer sum = num1 + num[j];
				sumsOfTwoNumber.add(sum);

				ArrayList<Integer> index = new ArrayList<Integer>(2);
				index.add(i);
				index.add(j);

				ArrayList<ArrayList<Integer>> indexList = mapForSums.get(sum);
				if (indexList != null) {
					indexList.add(index);
				} else {
					indexList = new ArrayList<ArrayList<Integer>>();
					indexList.add(index);
					mapForSums.put(sum, indexList);
				}
			}
		}

		ArrayList<Integer> sumList = new ArrayList<Integer>(sumsOfTwoNumber.size());
		sumList.addAll(sumsOfTwoNumber);
		Collections.sort(sumList);

		HashSet<ArrayList<Integer>> marks = new HashSet<ArrayList<Integer>>();
		int i = 0, j = sumList.size() - 1;
		while (i <= j) {
			int sumA = sumList.get(i);
			int sumB = sumList.get(j);
			int sum4 = sumA + sumB;
			int binary = 2;
			if (sum4 > target) {
				while (true) {
					if (sumA + sumList.get(j - j / binary) > target) {
						j = j - j / (binary) - 1;
						break;
					} else {
						binary *= 2;
						if (binary < 0) {
							--j;
							break;
						}
					}
				}
			} else if (sum4 < target) {
				while (true) {
					if (sumList.get(i + (j - i) / binary) + sumB < target) {
						i = i + (j - i) / (binary) + 1;
						break;
					} else {
						binary *= 2;
						if (binary < 0) {
							++i;
							break;
						}
					}
				}
			} else {
				ArrayList<ArrayList<Integer>> indexes1 = mapForSums.get(sumList
						.get(i));
				ArrayList<ArrayList<Integer>> indexes2 = mapForSums.get(sumList
						.get(j));
				for (int m = 0; m < indexes1.size(); ++m) {
					for (int n = 0; n < indexes2.size(); ++n) {
						TreeSet<Integer> allIndex = new TreeSet<Integer>();
						allIndex.addAll(indexes1.get(m));
						allIndex.addAll(indexes2.get(n));
						if (allIndex.size() == 4) {
							ArrayList<Integer> result = new ArrayList<Integer>();
							Iterator<Integer> iter = allIndex.iterator();
							for (int x = 0; x < 4; ++x) {
								result.add(num[iter.next()]);
							}
							Collections.sort(result);
							marks.add(result);
						}
					}
				}
				if (sumList.get(j) * 2 > target) {
					--j;
				} else {
					++i;
				}
			}
		}
		results.addAll(marks);
		return results;
    }
}
后来发现已经用了hash，不用排序也可以，省了排序的时间，把二分查找去掉，从O(logN*(N^2))降到了O(lN^2)，但是由于后面的复杂度比较复杂，整体的复杂度还是比较高。不知道是否把输入中出现4次以上的数可以去掉，但是那样代码就比较长了。

这是新的小板凳，虽然时间只提高了几十ms，但是代码简洁了很多。

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
		ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
		if (num.length < 4) {
			return results;
		}
		int length = num.length;
		Set<Integer> sumsOfTwoNumber = new HashSet<Integer>();
		HashMap<Integer, ArrayList<ArrayList<Integer>>> mapForSums = new HashMap<Integer, ArrayList<ArrayList<Integer>>>();

		for (int i = 0; i < length; ++i) {
			int num1 = num[i];
			for (int j = i + 1; j < length; ++j) {
				Integer sum = num1 + num[j];
				sumsOfTwoNumber.add(sum);

				ArrayList<Integer> index = new ArrayList<Integer>(2);
				index.add(i);
				index.add(j);

				ArrayList<ArrayList<Integer>> indexList = mapForSums.get(sum);
				if (indexList != null) {
					indexList.add(index);
				} else {
					indexList = new ArrayList<ArrayList<Integer>>();
					indexList.add(index);
					mapForSums.put(sum, indexList);
				}
			}
		}

		ArrayList<Integer> sumList = new ArrayList<Integer>();
		sumList.addAll(sumsOfTwoNumber);
		HashSet<ArrayList<Integer>> marks = new HashSet<ArrayList<Integer>>();
		for (int i = 0; i < sumList.size(); ++i) {
			int sumA = sumList.get(i);
			int sumB = target - sumA;

			ArrayList<ArrayList<Integer>> indexB = mapForSums.get(sumB);
			if (indexB != null) {
				ArrayList<ArrayList<Integer>> indexA = mapForSums.get(sumA);
				for (int m = 0; m < indexA.size(); ++m) {
					for (int n = 0; n < indexB.size(); ++n) {
						TreeSet<Integer> allIndex = new TreeSet<Integer>();
						allIndex.addAll(indexA.get(m));
						allIndex.addAll(indexB.get(n));
						if (allIndex.size() == 4) {
							ArrayList<Integer> result = new ArrayList<Integer>();
							Iterator<Integer> iter = allIndex.iterator();
							for (int x = 0; x < 4; ++x) {
								result.add(num[iter.next()]);
							}
							Collections.sort(result);
							marks.add(result);
						}
					}
				}
			}
		}

		results.addAll(marks);
		return results;
    }
}
看了别人的小板凳后，重写了一下，运行时间又缩减了100ms左右。目前是（716ms） 

public class Solution {
    public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
		ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
		if (num.length < 4) {
			return results;
		}
		int length = num.length;
		HashMap<Integer, ArrayList<ArrayList<Integer>>> mapForSums = new HashMap<Integer, ArrayList<ArrayList<Integer>>>();
		HashSet<ArrayList<Integer>> marks = new HashSet<ArrayList<Integer>>();

		for (int i = 0; i < length; ++i) {
			int num1 = num[i];
			for (int j = i + 1; j < length; ++j) {
				int num2 = num[j];
				int sumA = num1 + num2;

				int sumB = target - sumA;
				ArrayList<ArrayList<Integer>> indexB = mapForSums.get(sumB);
				if (indexB != null) {
					for (int n = 0; n < indexB.size(); ++n) {
						int k = indexB.get(n).get(0);
						int l = indexB.get(n).get(1);
						if (k != i && k != j && l != i && l != j) {
							ArrayList<Integer> result = new ArrayList<Integer>();
							result.add(num1);
							result.add(num2);
							result.add(num[k]);
							result.add(num[l]);
							
							Collections.sort(result);
							marks.add(result);
						}
					}
				}

				ArrayList<Integer> index = new ArrayList<Integer>();
				index.add(i);
				index.add(j);

				ArrayList<ArrayList<Integer>> indexList = mapForSums.get(sumA);
				if (indexList != null) {
					indexList.add(index);
				} else {
					indexList = new ArrayList<ArrayList<Integer>>();
					indexList.add(index);
					mapForSums.put(sumA, indexList);
				}
			}
		}

		results.addAll(marks);
		return results;
    }
}

Erorr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
4Sum——LeetCode
weixin_33893473的博客
06-12 80
这是我刷题时，在观看solutions时看到的方法，此方法时间复杂度为o(n^3) 空间复杂度为o(1)。此方法思想最大优点是，可以将其运用到所有关于KSum这类算法中。 Talk ischeap， Show me the code. public List<List<Integer>> fourSum(int[] nums, int target) { A...
4Sum -- LeetCode
热门推荐
Code Ganker
05-01 2万+
原题链接: http://oj.leetcode.com/problems/4sum/  这道题要求跟3Sum差不多，只是需求扩展到四个的数字的和了。我们还是可以按照3Sum中的解法，只是在外面套一层循环，相当于求n次3Sum。我们知道3Sum的时间复杂度是O(n^2)，所以如果这样解的总时间复杂度是O(n^3)。代码如下：public ArrayList> fourSum(int[] num,
4Sum_leetCode
王伴农
10-05 750
Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target. Note: Elements
4Sum---LeetCode
鱼思故渊的专栏
04-01 448
题目： Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target. Not
LeetCode:4Sum
WenzhenHe的博客
12-17 199
题目链接：https://leetcode.com/problems/4sum/description/ 题目介绍：给定一个数组S，在数组S中找出所有唯一的4个数，它们之和等于目标值 解题思路： 代码如下： vector> fourSum(vector& nums, int target) { vector> result; if (nums.size() < 4) ret
python数组双指针算法求和问题LeetCode2sum3sum4sum含代码
01-14
本文将深入探讨如何使用Python实现双指针算法来解决LeetCode中的2sum、3sum和4sum问题，并提供相关代码示例。 首先，我们来看2sum问题。给定一个整数数组`nums`和一个目标值`target`，我们需要找到数组中两个数的...
文档python数组双指针算法求和问题LeetCode2sum3sum4sum含代码
最新发布
04-17
文档python数组双指针算法求和问题LeetCode2sum3sum4sum含代码提取方式是百度网盘分享地址
leetcode3sum-LeetCode:leetcode问题用C#解决
06-29
3sum 力码 力扣算法 （注：“ :locked: " 表示你需要来自 Leetcode) # 标题 解决方案 困难 001 简单的 002 中等的 003 中等的 004 难的 005 中等的 006 简单的 007 简单的 008 简单的 009 简单的 010 难的 011 中等...
oj.leetcode 2sum 解
10-07
oj.leetcode题解，　２ｓｕｍ，　运用ｈａｓｈｔａｂｌｅ解决这到问题，时间复杂度O(N)
leetcode2sum-Problems:编程问题的回购
07-06
LC4: Longest Palindromic Substring [Medium] LC5: Median Of Two Sorted Arrays [Hard] LC6: Zigzag Conversion [Medium] LC7: Reverse Integer [Easy] LC8: String To Integer Atoi [Medium] LC9: Palindrome ...
LeetCode: 4Sum
Tingmei的专栏
09-30 7053
Problem: Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
Leetcode: 4Sum
ZkvIA的博客
10-08 7871
Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target. Note:
LeetCode 4Sum
DRFish
12-21 1373
找出一个列表中四个元素之和为目标值的情况，打印出所有的情况。
LeetCode - 4Sum
RojerAlone的博客
03-24 289
题目　　输入一个数组和一个目标值，返回所有的4个数的和等于目标值的组合。思路　　这个问题是 TwoSum 、3Sum 的变种，和3Sum一样，先确定一个值，然后从剩下的数组中找一个3Sum的结果，再把当前值加入，逐次遍历即可。代码public List<List<Integer> > fourSum(int[] nums, int target) { List<List<Integer> >
[Leet Code] 4sum
moyedamo的专栏
07-14 390
主要思想就是先排序，然后再求和，foursum的是复杂度ke
LeetCode之 4Sum
蒙奇·D·路飞的博客
05-16 181
开心也是一天，不开心也是一天，我选择开心 LeetCode官网：https://leetcode.com/ 我是直接用GitHub授权登录的。 问题 Given an array nums of n integers and an integer target, are there elements a, b, c, and d in nums such that a + b + ...
LeetCode 18: 4Sum
哈哈的个人专栏
06-02 3440
Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target. Note: Elements
LeetCode之4Sum（经典）
奔跑的小河
06-07 970
题目： Given an array S of n integers, are there elements a,b,c, and d in S such that a+b+c+d = target? Find all unique quadruplets in the array which gives the sum of target. Note: • Elements in a q
LeetCode18.四数之和(4sum)——双指针法和回溯法
e891377的专栏
10-05 569
LeetCode18.四数之和 给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。 注意： 答案中不可以包含重复的四元组。 示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-
leetcode tosum
07-27
LeetCode题目“Two Sum”是一个非常经典且常见的问题。这个问题要求在一个给定的整数数组中，找到两个数的和等于给定目标值，然后返回这两个数的索引。 我们可以使用暴力解法来解决这个问题。具体步骤如下： 1. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值