day_07
传送门
454. 四数相加 II - 返回满足要求的四元组个数
-
思路
-
思路一： 暴搜
-
思路二： 取出一个数组构建 hash表进行查询
- a + b + c + d = 0 =======> (a+b+c) + d = 0 =======> a + b + c = 0 - d
- 发现可以变为一个等式，等式可以看作一边的数在 hash表里，另一边是待查询的数
-
思路三： 取出两个数组构建 hash表进行查询，上边取出了一个数，这次我们多取一个数出来
- a + b + c + d = 0 =======> (a+b) + (c+d) = 0 =======> a + b = 0 - (c + d)
-
共同点：都将原来的数量关系转为一个等式，并尽量让两边变量平衡，该类等式就可以考虑使用 hash表
-
思路三代码实现
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
// a + b + c + d = 0 =======> (a+b) + (c+d) = 0 =======> a + b = 0 - (c + d)
// 发现 hash表的左右两边等式，就可以看作是一个在 hash表里，一个是要去表里查询的数
HashMap<Integer, Integer> arr1_arr2_sumMap = new HashMap<>(); // 一二数组进行求和，<k-和，v-次数>
int ans = 0;
for (int cur1 : nums1) { // 求出 a + b , 将同值存入表中
for (int cur2 : nums2) {
if(arr1_arr2_sumMap.containsKey(cur1 + cur2)){ // 之前存在该数，就更新
int times = arr1_arr2_sumMap.get(cur1 + cur2); // 循环的时候，两数组的二元组不会有重复的(a1,a2)
arr1_arr2_sumMap.put(cur1 + cur2, times + 1);
}
else arr1_arr2_sumMap.put(cur1+cur2 , 1);
}
}
int find = 0; // 根据循环得出要查找的目标值
for (int cur3 : nums3) { // 开始遍历后两个数组
for (int cur4 : nums4) {
find = 0 - (cur3 + cur4);
if (arr1_arr2_sumMap.containsKey(find)){
ans += arr1_arr2_sumMap.get(find); // 后两数组每遍历到后，要与原先的搭配的，会有v个符合的四元组
}
}
}
return ans;
}
}
383. 赎金信
-
无脑hash表处理就好
- 因为是个很明显的 查询一个元素有没有在集合里出现 的问题
- 选择使用 hash表处理的方式
-
代码实现
-
java - 选 magazine 建表
class Solution { public boolean canConstruct(String ransomNote, String magazine) { int letter[] = new int[26]; for (int i = 0; i < magazine.length(); i++){ //遍历magazine建表 int index = magazine.charAt(i) - 'a'; letter[index]++; } for (int i = 0; i < ransomNote.length(); i++){ int index = ransomNote.charAt(i) - 'a'; --letter[index]; if (letter[index] < 0) return false; // < 0 说明杂志上的字母不够用 } return true; } }- C语言 - 选 ransomNote 建表
bool canConstruct(char * ransomNote, char * magazine){ int letter[26]; memset(letter, 0 , sizeof(letter)); // 刷新数组的值 int index; // 遍历 ransomNote，构建 hash表 while(*ransomNote){ index = *ransomNote - 'a'; ++letter[index]; ransomNote++; // 记得移动指针 } // 遍历 magazine，去表里面处理 while(*magazine){ index = *magazine - 'a'; if(letter[index] != 0){ // 丢弃用不到的字母和已经处理好的字母 --letter[index]; } magazine++; } // 看看表里的情况，救赎信里要是有 != 0 的数，说明不可以 for(int i = 0 ; i < 26; i++){ if(letter[i] != 0) return false; } return true; }
-
-
小结
- 字符串类使用 hash表的时候，选择哪个建表比较好？
- 选长度更长的，这个题里就是 magazine, 例子里给出了他可以更长
- 大覆盖小的时候发现有地方覆盖不到，就可以直接退出了
- 反之如果小匹配大的话，要多一步操作的，不太推荐
- 字符串类使用 hash表的时候，选择哪个建表比较好？
15. 三数之和
-
第一眼，直接 O(n^3暴搜)
-
第二眼，a + b = 0 - c，遍历C 构造出一个哈希表 < 数字，list<下标> >
- 发现很麻烦，因为不单单是查找数字，还要看看 list 里的下标使用情况，每一次查表时，当前用过同一数字下标的就不能再使用了
-
暂时没有更好的法子了
-
卡哥的方法: 双指针法
- 先排序
- 定义三个指针，i, left(i + 1), right(size -1)，每次遍历i的时候，记得初始化 left、right 指针
- 开始遍历 i 指针，求出 三数的和，和 0 对比，根据对比结果移动 left，right,直到相遇，一轮循环结束
- > 0 的情况：right-- =====> c > - (a + b)，所以让 c 的值降一降
- < 0 的情况：left++ =====> b < - (a + c)，所以让 b 的值增一增
- 找到符合条件的就记录下来，循环直到 nums[i] > 0 || left = right时，就可以退出循环了
- 难点，只留一组符合的三元组，如何去重？
- 现在已经排好序了，就选 i 符合的三元组，每一个不同的 i 都可能有多个不同的三元组
- 所以对三个数都要去重，怎么去重？
- 对 i 去重：当前选过的 i 是之前没有选过的 nums[i]!=nums[i-1]
- 对 left 去重：先选一个符合条件的left，然后对 left 不断++，直到出现新的 left
- 对 right 去重：思路和 left 相同， right–就行
-
java代码实现
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList<>(); // 存储答案
Arrays.sort(nums); // 先对数组排序
if (nums.length < 3 || nums[0] > 0){ // 排除特殊情况
return ans;
}
// 开始遍历
for (int i = 0; i < nums.length; i++) { // 寻找nums[i]的三元组
int left = i + 1;
int right = nums.length - 1;
if(i > 0 && nums[i] == nums[i - 1]) continue; // 对 i 进行去重
// 寻找满足的三元组并对其去重
while (left < right){ // 开始对 left、right去重
int oldRight = nums[right];
int oldLeft = nums[left];
int sum = nums[i] + nums[left] + nums[right]; // 求出三数和
if (sum > 0 ){ // 如果 sum不符合，就直接过滤掉这个数
right--;
}
else if(sum < 0){
left++;
}
else { // 看看去重后的三个元素是否满足条件
List<Integer> list = new ArrayList<>(); // 存储单个三元组
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
ans.add(list);
// 添加完这个数据之后，就可以对该三元组进行去重了
while (right > left && nums[left] == oldLeft){ // right > left 一定要加，否则 [0,0,0,0,0,0,0]就会直接出问题了
left++;
}
while (right > left && nums[right] == oldRight){
right--;
}
}
}
}
return ans;
}
}
18. 四数之和
-
暴搜？肯定能出结果，但是太慢了
-
发现这个题要返回的也是具体下标组成的元组，如果要用哈希表的话，也要判断下标情况才行，上面判断两个下标，这个就要判断三个了，痛苦哇
-
反过来，上面三数之和的指针遍历法似乎很不错，扩展一下一个可以处理
-
代码实现如下
- 注意点
- 这次的四数和为 target，可正可负，不能单纯的 nums[i] > target 了
- 每个指针的更新位置一定要正确
- 注意点
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> ans = new ArrayList<>();
if (nums.length < 4) return ans;
Arrays.sort(nums); // 排序
// 开始处理
for (int i = 0; i < nums.length; i++) {
int right = nums.length - 1; // 定义右指针,不能放在这里，这是因为，下面处理完后，先返回到 j 的循环里面，在 j 的循环里就应该更新 right 了！
int left = i + 2;
if (i > right - 3 || (nums[i] > 0 && nums[i] > target) ){ // 退出条件
break;
}
if (i > 0 && nums[i - 1] == nums[i]){ // 给 i 去重
continue;
}
int j = i + 1;
// 开始三数循环，指定一个左到右的指针
for ( ; j < nums.length; j++) {
if (j > i + 1 && nums[j - 1] == nums[j]) // 对 j 去重
continue;
left = j + 1;
right = nums.length - 1;
while (left < right) {
long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
if (sum > target) { // 不符合条件的直接过滤掉就行
right--;
} else if (sum < target) {
left++;
} else { // 符合条件的先保存，再去重
ans.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
while (left < right && nums[right] == nums[right - 1]) right--;
while (left < right && nums[left] == nums[left + 1]) left++;
right--;
left++;
}// else
}// while
}// for
}// for
return ans;
}
}
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
