Task04：查找2
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解析
使用一层循环，每遍历到一个元素就计算该元素与 targettarget 之间的差值，然后到 HashMapHashMap 中寻找该差值，如果找到，则返回两个元素在数组 numsnums 的下标，如果没有找到，则将当前元素存入 HashMapHashMap 中 (Key: nums[i], Value: i(Key:nums[i],Value:i) 。
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer,Integer> map = new HashMap<>();
int[] res = new int[2];
for (int i = 0; i < nums.length; i++) {
int dif = target - nums[i];
if (map.get(dif) != null) {
res[0] = map.get(dif);
res[1] = i;
return res;
}
map.put(nums[i],i);
}
return res;
}
}
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
解析
先排序，确定一个值，和一个结果target，然后在排序数组中通过二分法查找两个数字的和等于target的值，查找的时候注意要过滤掉重复的值。
public List<List<Integer>> threeSum(int[] num) {
Arrays.sort(num);
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < num.length - 2; i++) {
if (i == 0 || (i > 0 && num[i] != num[i - 1])) {
int left = i + 1, right = num.length - 1, target = -num[i];
while (left < right) {
int midVale = num[left] + num[right];
if (midVale == target) {
res.add(Arrays.asList(num[i], num[left], num[right]));
while (left < right && num[left] == num[left + 1])//过滤掉重复的
left++;
while (left < right && num[right] == num[right - 1])//过滤掉重复的
right--;
left++;
right--;
} else if (midVale < target)
left++;
else
right--;
}
}
}
return res;
}
16. 最接近的三数之和
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
解析
双指针法
先让数组有序，也就是需要先对数组进行排序
然后每次固定一个元素，再去寻找另外两个元素，也就是双指针
双指针法的代码实现
利用 Arrays.sort(nums) 对数组进行排序。
初始化一个用于保存结果的值 result = nusm[0] + nums[1] + nums[2] （不要自己设初值，直接从数组中抽取三个元素，假设这是最接近的三数之和，然后再更新就是了）。
利用下标 i 对数组进行遍历，此时就是在固定第一个元素，注意，下标 i 的边界为 i < nums.length-2，否则设置指针的时候会出现数组越界。
每次遍历的过程中设置两个指针，分别是 left = i + 1、right = nums.length - 1。
检查 sum = nums[i] + nums[left] + nums[right]与 target 的距离，如果该距离比之前保存的 result 与 target 的距离更小，就更新 result。
然后就是移动双指针。
如果 sum 的值比 target 大，那么我们让 right–，因为数组是有序的，right --会使得下一次的 sum 更小，也就更接近 target 的值
同理，如果 sum 的值 target 小，那么我们让 left++。·
left++ 和 right-- 的界限自然是 left != right，如果 left == right，说明我们已经将所有的元素都遍历过一遍了。
重复上面的操作，直到i循环结束为止，返回 result
优化：添加去重操作
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int result = nums[0] + nums[1] + nums[2];
for(int i=0;i<nums.length-2;i++){
int left = i+1;
int right = nums.length - 1;
while(left != right){
int sum = nums[i] + nums[left] + nums[right];
if(Math.abs(sum - target) < Math.abs(result - target))
result = sum;
if(sum > target){
right--;
// 解决nums[right]重复
while(left != right && nums[right] == nums[right+1])
right--;
}
else{
left++;
// 解决nums[left]重复
while(left != right && nums[left] == nums[left-1])
left++;
}
}
// 解决nums[i]重复
while(i<nums.length-2 && nums[i] == nums[i+1])
i++;
}
return result;
}
}
18. 四数之和
给定一个包含 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],
[-2, 0, 0, 2]
]
解析：
采用四个指针的形式，前两个遍历，后面两个用了检验数据是否正确.
注意点:
. 不能重复，尽量遍历过的不能重新遍历
. 后两个指针从头和尾分别开始，减少时间复杂度。
指针活动范围：
1、i指针从0开始到倒数第三个；
2、j指针从i后面开始到倒数第二个；
3、left从前往后，right从后往前，活动范围是从j开>始到最后，left和right类似两数之和的问题。
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> result = new ArrayList<>();
//先排序
Arrays.sort(nums);
for (int i = 0;i < nums.length - 2;i ++) {
// 去除指针i可能的重复情况
if (i != 0 && nums[i] == nums[i-1]) {
continue;
}
for (int j = i + 1;j < nums.length;j ++) {
// 去除j可能重复的情况
if (j != i + 1 && nums[j] == nums[j-1]) {
continue;
}
int left = j + 1;
int right = nums.length -1;
while (left < right) {
// 不满足条件或者重复的，继续遍历
if ((left != j + 1 && nums[left] == nums[left-1]) || nums[i] + nums[j] + nums[left] + nums[right] < target) {
left ++;
} else if ((right != nums.length -1 && nums[right] == nums[right + 1]) || nums[i] + nums[j] + nums[left] + nums[right] > target) {
right --;
} else {
List<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[left]);
list.add(nums[right]);
result.add(list);
// 满足条件的，进入下一次遍历
left ++;
right --;
}
}
}
}
return result;
}
}
49. 字母异位词分组
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例:
输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]
说明：
所有输入均为小写字母。
不考虑答案输出的顺序。
解析：
将每个字符串按照字母顺序排序，这样的话就可以把 eat，tea，ate 都映射到 aet。其他的类似
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
HashMap<String, List<String>> hash = new HashMap<>();
for (int i = 0; i < strs.length; i++) {
char[] s_arr = strs[i].toCharArray();
//排序
Arrays.sort(s_arr);
//映射到 key
String key = String.valueOf(s_arr);
//添加到对应的类中
if (hash.containsKey(key)) {
hash.get(key).add(strs[i]);
} else {
List<String> temp = new ArrayList<String>();
temp.add(strs[i]);
hash.put(key, temp);
}
}
return new ArrayList<List<String>>(hash.values());
}
}
解析：
可以用 HashMap 去计数，斜率作为 key，然后遍历平面上的其他点，相同的 key 意味着在同一条直线上。
用分数去表示斜率，求分子分母的最大公约数，然后约分，最后将 「分子 + “@” + “分母”」作为 key 即可。
当确定某个点的时候，平面内如果有和这个重叠的点，如果按照正常的算法约分的话，会出现除 0 的情况，所以需要单独用一个变量记录重复点的个数，而重复点一定是过当前点的直线的。
class Solution {
public int maxPoints(int[][] points) {
if (points.length < 3) {
return points.length;
}
int res = 0;
//遍历每个点
for (int i = 0; i < points.length; i++) {
int duplicate = 0;
int max = 0;//保存经过当前点的直线中，最多的点
HashMap<String, Integer> map = new HashMap<>();
for (int j = i + 1; j < points.length; j++) {
//求出分子分母
int x = points[j][0] - points[i][0];
int y = points[j][1] - points[i][1];
if (x == 0 && y == 0) {
duplicate++;
continue;
}
//进行约分
int gcd = gcd(x, y);
x = x / gcd;
y = y / gcd;
String key = x + "@" + y;
map.put(key, map.getOrDefault(key, 0) + 1);
max = Math.max(max, map.get(key));
}
//1 代表当前考虑的点，duplicate 代表和当前的点重复的点
res = Math.max(res, max + duplicate + 1);
}
return res;
}
private int gcd(int a, int b) {
while (b != 0) {
int temp = a % b;
a = b;
b = temp;
}
return a;
}
}
219. 存在重复元素 II
给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。
示例 1:
输入: nums = [1,2,3,1], k = 3
输出: true
解析：
维护一个哈希表，里面始终最多包含 k 个元素，当出现重复值时则说明在 k 距离内存在重复元素;每次遍历一个元素则将其加入哈希表中，如果哈希表的大小大于 k，则移除最前面的数字
class Solution {
public boolean containsNearbyDuplicate(int[] nums, int k) {
HashSet<Integer> set = new HashSet<>();
for(int i = 0; i < nums.length; i++) {
if(set.contains(nums[i])) {
return true;
}
set.add(nums[i]);
if(set.size() > k) {
set.remove(nums[i - k]);
}
}
return false;
}
}
220. 存在重复元素 III
在整数数组 nums 中，是否存在两个下标 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值小于等于 t ，且满足 i 和 j 的差的绝对值也小于等于 ķ 。
如果存在则返回 true，不存在返回 false。
示例 1:
输入: nums = [1,2,3,1], k = 3, t = 0
输出: true
解析：
暴力法
public class Solution {
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
int len = nums.length;
long a;
long b;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len && j <= i + k; j++) {
a = nums[i];
b = nums[j];
if (Math.abs(a - b) <= t) {
return true;
}
}
}
return false;
}
}
447. 回旋镖的数量
给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。
找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。
示例:
输入:
[[0,0],[1,0],[2,0]]
输出:
2
解释:
两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
解析：
对于每一个点，都计算其它点与它的距离，然后把这个距离放入map中作为key，满足这一距离的其它点的个数作为value。
比如与点A相距10的点有5个，那么可能的组合就有5*4种方式。
遍历一遍关于点A的map，对于所有的距离下的个数都计算出可能的组合方式再相加，就得到对于一个点来说满足要求的所有组合。
在外面再套一层循环，就可以获得所有点相对于其它点的map，也就可以获得所有的组合个数，也就是我们需要的返回值
class Solution {
public int numberOfBoomerangs(int[][] points) {
int res = 0;
//O(n^2)
for(int i = 0; i < points.length;i++){
Map<Integer, Integer> record = new HashMap<>();
for(int j = 0; j < points.length; j ++){
if( j != i )
if(record.containsKey(distance(points[i], points[j]))){
record.put(distance(points[i], points[j]),
record.get(distance(points[i], points[j])) + 1);
}
else
record.put(distance(points[i], points[j]), 1);
}
for(int k : record.values()){
if(k >= 2)//这里其实可以不加这句，因为k=1或k=0，结果都是0，但是加上可以减少一定的计算量。
res += k * (k - 1);
}
}
return res;
}
private int distance(int[] x, int[] y){
return (x[0] - y[0]) * (x[0] - y[0]) + (x[1] - y[1]) * (x[1] - y[1]);
}
}
454. 四数相加 II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
- (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
- (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
解析：
分为两组，HashMap存一组，另一组和HashMap进行比对。
HashMap存两个数组之和，如AB。然后计算两个数组之和，如CD。时间复杂度为：O(n2)+O(n2),得到O(n^2).
以存AB两数组之和为例。首先求出A和B任意两数之和sumAB，以sumAB为key，sumAB出现的次数为value，存入hashmap中。
然后计算C和D中任意两数之和的相反数sumCD，在hashmap中查找是否存在key为sumCD。
class Solution {
public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
Map<Integer, Integer> map = new HashMap<>();
//Map<Integer, Integer> map = new HashMap<>();
int res = 0;
for(int i = 0;i<A.length;i++){
for(int j= 0;j<B.length;j++){
int sumAB = A[i]+B[j];
if(map.containsKey(sumAB)) map.put(sumAB,map.get(sumAB)+1);
else map.put(sumAB,1);
}
}
for(int i = 0;i<C.length;i++){
for(int j = 0;j<D.length;j++){
int sumCD = -(C[i]+D[j]);
if(map.containsKey(sumCD)) res += map.get(sumCD);
}
}
return res;
}
}
扫一扫
4193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
