哈希表进阶+双指针进阶(LeetCode刷题!!!)
跟着carl哥的第六天
今天两道哈希表,两道双指针
哈希表进阶
先看第一道题
leetcode454. 四数相加 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 。所有整数的范围在 -2^28 到 2^28 - 1 之间,最终结果不会超过 2^31 - 1 。
示例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
思路:
这道题你可以把两个数看成一个数,然后就像昨天那篇文章的 leetcode1.两数之和 一个思想了,要注意的是把两个数看成一个数 要用什么数据结构呢? 需要存储两数相加的值 以及统计出现的次数
答案:::
public class test01 {
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
//读入一行,并按照空格拆分
String[] nums1 = in.readLine().split(",");
String[] nums2 = in.readLine().split(",");
String[] nums3 = in.readLine().split(",");
String[] nums4 = in.readLine().split(",");
int[] arr1 = new int[nums1.length];
int[] arr2 = new int[nums1.length];
int[] arr3 = new int[nums1.length];
int[] arr4 = new int[nums1.length];
for (int i = 0; i < nums1.length; i ++) {
arr1[i] = Integer.parseInt(nums1[i]);
arr2[i] = Integer.parseInt(nums2[i]);
arr3[i] = Integer.parseInt(nums3[i]);
arr4[i] = Integer.parseInt(nums4[i]);
}
int count = fourSumCount(arr1, arr2, arr3, arr4);
out.write(count);
out.flush();
out.close();
}
private static int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
//把四个数变成 两两相加的数(并且记录出现的次数)
int count = 0; //记录满足的个数
int temp = 0; //中间值:"两数相加"
Map<Integer, Integer> map = new HashMap<>();
//前两数相加
for (int i = 0; i < nums1.length; i ++) {
for (int j = 0; j < nums1.length; j ++) {
temp = nums1[i] + nums2[j];
if (map.containsKey(temp)) {
map.put(temp, map.get(temp) + 1);
} else {
map.put(temp, 1);
}
}
}
//后两数相加再验证()
for (int i = 0; i < nums1.length; i ++) {
for (int j = 0; j < nums1.length; j ++) {
temp = nums3[i] + nums4[j];
if (map.containsKey(0 - temp)) {
count += map.get(0 - temp);
}
}
}
return count;
}
}
再看第二道题
leetcode383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串,判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成,返回 true ;否则返回 false。
(题目说明:为了不暴露赎金信字迹,要从杂志上搜索各个需要的字母,组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
示例1 :
输入:ransomNote = "a", magazine = "b"
输出:false
示例2 :
输入:ransomNote = "aa", magazine = "ab"
输出:false
示例3 :
输入:ransomNote = "aa", magazine = "aab"
输出:true
思路:这道题跟昨天文章的leetcode242.有效的字母异位词有点像,大家可以试着做做,我在答案里写了做题时的思想
答案:
public class test02 {
//定义输入输出
public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
//读入一行,并按照空格拆分
String ransomNote = in.readLine();
String magazine = in.readLine();
boolean flag = canConstruct(ransomNote, magazine);
System.out.println(flag);
out.flush();
out.close();
}
//magazine中所有的字母可以组成ransomNote 并且magazine中的每个字符只能使用一次
private static boolean canConstruct(String ransomNote, String magazine) {
boolean flag = false;
//感觉得用map 因为magazine中每个字符只能用一次
//所以key记录字符,value记录字符数目
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < magazine.length(); i ++) {
//如果map中存在该字符,则++, 如果没包含则加入到map
if (map.containsKey(magazine.charAt(i))) {
map.put(magazine.charAt(i), map.get(magazine.charAt(i)) + 1);
} else {
map.put(magazine.charAt(i), 1);
}
}
for (int i = 0; i < ransomNote.length(); i ++) {
//如果map中存在该字符,则--, 如果没有则返回false
if (map.containsKey(ransomNote.charAt(i))) {
map.put(ransomNote.charAt(i), map.get(ransomNote.charAt(i)) - 1);
flag = true;
if (map.get(ransomNote.charAt(i)) < 0) {
flag = false;
break;
}
} else {
return false;
}
}
return flag;
}
}
双指针进阶
第一道题
leetcode15.三数之和
给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 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 。
思路:
- 使用双指针法, 一个指针指向左边界(i的下一位),一个指针指向右边界,还有一个for循环的i , 大概意思就是定住i 然后两个指针往中间遍历,寻找合适的值sum
- 如果 sum > 0 则右边界左移(right --),sum < 0 则左边界右移(left ++)
- 因为数组不能重复,所以需要判重
- 可以想想可以怎么剪枝
答案:
public class test03 {
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
//读入一行,并按照空格拆分
String[] nums = in.readLine().split(",");
int[] arr = new int[nums.length];
for (int i = 0; i < nums.length; i ++)
arr[i] = Integer.parseInt(nums[i]);
List<List<Integer>> result = threeSum(arr);
out.write(result.toString());
out.flush();
out.close();
}
public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
//如果数组元素小于三或者第一元素大于0又或者最后元素小于0
if (nums.length < 3 || nums[0] > 0 || nums[nums.length - 1] < 0)
return result;
//首尾相等,所以全0
if (nums[0] == 0 && nums[nums.length - 1] == 0){
result.add(Arrays.asList(0, 0, 0));
return result;
}
//使用双指针法, 一个指针指向左边界(i的下一位),一个指针指向右边界
//如果 sum > 0 则右边界左移,sum < 0 则左边界右移
for (int i = 0; i < nums.length; i ++) {
//i判重
//为什么不写nums[i] == nums[i + 1]呢
//因为nums[i + 1] = left 我们定义的时候nums[i]跟Left其实是本质不同的两个数
if (i > 0 && nums[i] == nums[i - 1])
continue;
//如果三个数中最小值大于0 则后面都不可能等于0
if (nums[i] > 0)
return result;
int left = i + 1;
int right = nums.length - 1;
while(left < right) {
int sum = nums[i] + nums[left] + nums[right];
if (sum > 0)
right --; //由于sum太大,所以右边界指针左移
else if (sum < 0)
left ++; //由于sum太小,所以左边界指针右移
else {
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
//左边界指针left 右边界指针right 判重
while(left < right && nums[left] == nums[left + 1])
left ++;
while(left < right && nums[right] == nums[right - 1])
right --;
left ++;
right --;
}
}
}
return result;
}
}
最后一道坚持一下!!!!
leetcode18.四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + 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]]
思路:
这道题跟第三题有点相似,但是要注意剪枝,给我剪了8个WA。。。
主要就还是在for循环外面再套一层for循环
答案:
public class test04 {
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) throws IOException {
//读入一行,并按照空格拆分
String[] arr = in.readLine().split(",");
int[] nums = new int[arr.length];
for (int i = 0; i < nums.length; i ++)
nums[i] = Integer.parseInt(arr[i]);
int target = Integer.parseInt(in.readLine());
List<List<Integer>> result = fourSum(nums, target);
out.write(result.toString());
out.flush();
out.close();
}
public static List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
/*
这里错了!!!! 因为负数相加更小,所以我们不能以nums[0]>target作为剪枝
//跟前面第三题一样,如果没有四个数,或者数组中最小数大于target
if (nums.length < 4 || nums[0] > target)
return result;
*/
//一样使用双指针法,就是在第三题的情况下再外面再套一层for循环(最极限的情况下保证还有三个数给其余三个数用)
for (int i = 0; i < nums.length - 3; i ++) {
//因为只有当nums[i]大于0判断才有用,不然当nums[i] target均为负数时判断不准确
if (nums[i] > 0 && nums[i] > target) {
return result;
}
//i判重
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
for (int j = i + 1; j < nums.length - 2; j ++) {
//j判重
if (j > i + 1 && nums[j] == nums[j - 1]) {
continue;
}
int left = j + 1;
int right = nums.length - 1;
while (left < right) {
int sum = nums[i] + nums[j] + nums[left] + nums[right];
if (sum > target) {
right --;
} else if (sum < target) {
left ++;
} else {
result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
//左右指针判重
while(left < right && nums[left] == nums[left + 1])
left ++;
while(left < right && nums[right] == nums[right - 1])
right --;
left ++;
right--;
}
}
}
}
return result;
}
}
自我总结
越学越觉得算法的奇妙,特别是双指针, 而且哈希表也挺好玩的
要记住想在一个集合中快速查找到一个元素,用哈希表准没错!!
朋友仍需努力 一起加油
兄弟萌冲啊!
大概就是这样,大家懂了吗 有什么不懂的评论区评论或者私信我吧!!