两数之和
用哈希表的思路分析这个题目真的简单
我真的没培养出来这个习惯。。
java
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i< nums.length; i++) {
if(map.containsKey(target - nums[i])) {
return new int[] {map.get(target-nums[i]),i};
}
map.put(nums[i], i);
}
throw new IllegalArgumentException("No two sum solution");
}
}注意！！！
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]),i};
}
map.put(nums[i],i);
这两行代码的顺序不能更改！！！
更改的话有部分案例就不能通过。比如数组中有重复数据的情况
比如[3,3]，目标值是6
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]),i};
}
map.put(nums[i],i);
两个三没问题的，因为第一个三进到map之后第二个三和map中相加是6，直接就输出0，1了第二个不会进map的。
如果两行代码换了顺序，
map.put(nums[i],i);
if(map.containsKey(target-nums[i])){
return new int[]{map.get(target-nums[i]),i};
}
这样的话，第一个3，0put到map里面了，然后第二个3，1put到map里面直接覆盖了，然后输出的结果是[1,1]，错误❌
三数之和
这个题目，一点思路都没有，唉
这个题目关键点在于如何去重和三个数的怎么表示，我怎么没有一个排序的想法
java
class Solution {
public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList();
int len = nums.length;
if(nums == null || len < 3) return ans;
Arrays.sort(nums); // 排序
for (int i = 0; i < len ; i++) {
if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重，对每组结果的第一个数进行去重，nums[i]是当前值 nums[i+1]是下一个要判断的值 nums[i-1]是已经判断过的值 把当前值nums[i]和已经判断过的值nums[i-1]进行比较，如果一样就说明这个值已经判过了，这样更符合代码的逻辑意思，所以nums[i] == nums[i+1]
int L = i+1;
int R = len-1;
while(L < R){
int sum = nums[i] + nums[L] + nums[R];
if(sum == 0){
ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L++;
R--;
}
else if (sum < 0) L++;
else if (sum > 0) R--;
}
}
return ans;
}
}while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L在这个循环里会增加，增加到大于R就结束循环，所以必须增加这个条件L<R
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
**·**对每组结果的第一个数进行去重，nums[i]是当前值 nums[i+1]是下一个要判断的值 nums[i-1]是已经判断过的值 把当前值nums[i]和已经判断过的值nums[i-1]进行比较，如果一样就说明这个值已经判过了，这样更符合代码的逻辑意思，所以nums[i] == nums[i+1]
· if(i > 0 && nums[i] == nums[i-1])涉及到&&的懒加载机制，如果先写num[i]==nums[i-1]，会爆空指针异常！所以必须i > 0写在前面
四数之和
三数之和里面的这个左右移位去重的代码这样写的
while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L++;
R--;
四数之和里面的这个左右移位去重的代码这样写的
j++;
while(j<h&&nums[j]==nums[j-1]){
j++;
}
h--;
while(j<h&&i<h&&nums[h]==nums[h+1]){
h--;
其实意思是一样的，这个地方不要和前面三数之和对第一个元素去重的操作进行理解
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
（先move on然后再吃回头草比较一下hhh）
所以三数之和的代码为了和四树之和的代码统一一下，修改
java
class Solution {
public static List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList();
int len = nums.length;
if(nums == null || len < 3) return ans;
Arrays.sort(nums); // 排序
for (int i = 0; i < len ; i++) {
if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重，对每组结果的第一个数进行去重，nums[i]是当前值 nums[i+1]是下一个要判断的值 nums[i-1]是已经判断过的值 把当前值nums[i]和已经判断过的值nums[i-1]进行比较，如果一样就说明这个值已经判过了，这样更符合代码的逻辑意思，所以nums[i] == nums[i+1]
int L = i+1;
int R = len-1;
while(L < R){
int sum = nums[i] + nums[L] + nums[R];
if(sum == 0){
ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
L++;
while (L<R && nums[L] == nums[L-1]) L++; // 去重
R--;
while (L<R && nums[R] == nums[R+1]) R--; // 去重
}
else if (sum < 0) L++;
else if (sum > 0) R--;
}
}
return ans;
}
}
四树之和的代码
思路分析：其实就是在三数之和的外面又套了一层循环，先表示出一个数，然后再套用三数之和的模板
代码摘自
java
class Solution{
public List<List<Integer>> fourSum(int[] nums,int target){
/*定义一个返回值*/
List<List<Integer>> result=new ArrayList<>();
/*当数组为null或元素小于4个时，直接返回*/
if(nums==null||nums.length<4){
return result;
}
/*对数组进行从小到大排序*/
Arrays.sort(nums);
/*数组长度*/
int length=nums.length;
/*定义4个指针k，i，j，h k从0开始遍历，i从k+1开始遍历，留下j和h，j指向i+1，h指向数组最大值*/
for(int k=0;k<length-3;k++){
/*当k的值与前面的值相等时忽略*/
if(k>0&&nums[k]==nums[k-1]){
continue;
}
/*获取当前最小值，如果最小值比目标值大，说明后面越来越大的值根本没戏*/
long min1=(long)nums[k]+nums[k+1]+nums[k+2]+nums[k+3];
if(min1>target){
break;
}
/*获取当前最大值，如果最大值比目标值小，说明后面越来越小的值根本没戏，忽略*/
long max1=(long)nums[k]+nums[length-1]+nums[length-2]+nums[length-3];
if(max1<target){
continue;
}
/*第二层循环i，初始值指向k+1*/
for(int i=k+1;i<length-2;i++){
/*当i的值与前面的值相等时忽略*/
if(i>k+1&&nums[i]==nums[i-1]){
continue;
}
/*定义指针j指向i+1*/
int j=i+1;
/*定义指针h指向数组末尾*/
int h=length-1;
/*获取当前最小值，如果最小值比目标值大，说明后面越来越大的值根本没戏*/
long min=(long)nums[k]+nums[i]+nums[j]+nums[j+1];
if(min>target){
break;
}
/*获取当前最大值，如果最大值比目标值小，说明后面越来越小的值根本没戏，忽略*/
long max=(long)nums[k]+nums[i]+nums[h]+nums[h-1];
if(max<target){
continue;
}
/*开始j指针和h指针的表演，计算当前和，如果等于目标值，j++并去重，h--并去重，当当前和大于目标值时h--，当当前和小于目标值时j++*/
while (j<h){
long curr=(long)nums[k]+nums[i]+nums[j]+nums[h];
if(curr==target){
result.add(Arrays.asList(nums[k],nums[i],nums[j],nums[h]));
j++;
while(j<h&&nums[j]==nums[j-1]){
j++;
}
h--;
while(j<h&&i<h&&nums[h]==nums[h+1]){
h--;
}
}else if(curr>target){
h--;
}else {
j++;
}
}
}
}
return result;
}
}四数相加
确实超理解的题解，但是明天我自己做肯定做不出来
java
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;
}
}绝望了
感觉算法就是会就是会，不会就是不会，不会的看题解现在会了，明天就不会了，这个能力太难培养了