两数之和
用哈希表的思路分析这个题目真的简单
我真的没培养出来这个习惯。。
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");
}
}
三数之和
这个题目,一点思路都没有,唉
这个题目关键点在于如何去重和三个数的怎么表示,我怎么没有一个排序的想法
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)
所以三数之和的代码为了和四树之和的代码统一一下,修改
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;
}
}
四树之和的代码
思路分析:其实就是在三数之和的外面又套了一层循环,先表示出一个数,然后再套用三数之和的模板
代码摘自
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;
}
}
四数相加
确实超理解的题解,但是明天我自己做肯定做不出来
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;
}
}
绝望了
感觉算法就是会就是会,不会就是不会,不会的看题解现在会了,明天就不会了,这个能力太难培养了