代码随想录训练营D7-哈希表篇p2 | 454.四数相加II 、383. 赎金信 、15. 三数之和 、18. 四数之和

代码随想录训练营D7-哈希表篇p2 | 454.四数相加II 、383. 赎金信 、15. 三数之和 、18. 四数之和

  • (一) 454.四数相加II
    • 1. 思路
    • 2. 代码
    • 3. 实现过程中的问题
  • (二) 383. 赎金信
    • 1. 思路
    • 2. 代码
  • (三) 15. 三数之和
    • 1. 思路
    • 2. 代码
    • 3. 实现过程中的问题
  • (四) 18. 四数之和
    • 1. 思路
    • 2. 代码

(一) 454.四数相加II

建议:本题是 使用map 巧妙解决的问题,好好体会一下 哈希法 如何提高程序执行效率,降低时间复杂度,当然使用哈希法 会提高空间复杂度,但一般来说我们都是舍空间 换时间, 工业开发也是这样。

题目/文章/视频链接

1. 思路

普通思路,一定是4层for循环。

使用map的思路。
count变量,记录元祖的个数。
数组1、2可能中任选两个数相加,可能组成的和放入map(key:两数之和;value:出现的次数)。
再遍历数组3、4 ,两数组中也是各取一个元素求和;若当前数n,在map中有0 - n吗,若有将其value加在count上。

2. 代码

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    HashMap<Integer, Integer> map = new HashMap<>();
    int sum;
    for(int i = 0; i < nums1.length; ++i){
        for(int j = 0; j < nums2.length; ++j){
            sum = nums1[i] + nums2[j];
            map.put(sum, map.getOrDefault(sum, 0) + 1);
        }
    }
    int count = 0;
    for(int m : nums3){
        for(int n : nums4){
            sum = m + n;
            count += map.getOrDefault(0 - sum, 0);
        }
    }
    return count;
}

3. 实现过程中的问题

按foreach写法时,遍历的n已经就是元素了,而不是下标

for(int n : nums4){
    sum = m + n;
    count += map.getOrDefault(0 - sum, 0);
}

(二) 383. 赎金信

建议:本题 和 242.有效的字母异位词 是一个思路 ,算是拓展题

题目/文章/视频链接

题干:
给你两个字符串:ransomNote 和 magazine ,判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以,返回 true ;否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
(magazine提供字母)

1. 思路

使用哈希。数组的那种哈希。
1.创建一个长度为26的数组。
2.读入magazine。key,即数组下标为:当前char-’a‘;value: 该字母的个数。
3.读入ransom。遍历时,用到一个字母,就将对应的value–;同时判断,若该value为负数了,则返回false。
4.最后返回true

2. 代码

public boolean canConstruct(String ransomNote, String magazine) {
    int[] array = new int[26];
    for(int i = 0; i < magazine.length(); ++i){
        array[magazine.charAt(i) - 'a']++;
    }

    for(int j = 0; j < ransomNote.length(); ++j){
        if(--array[ransomNote.charAt(j) - 'a'] < 0){
            return false;
        }
    }
    return true;
}

(三) 15. 三数之和

建议:本题虽然和 两数之和 很像,也能用哈希法,但用哈希法会很麻烦,双指针法才是正解,可以先看视频理解一下 双指针法的思路,文章中讲解的,没问题 哈希法很麻烦。

题目/文章/视频链接

1. 思路

双指针法。
由于这里不需要返回元素的下标,所以可以对其进行排序。
for循环遍历,在其下一个位置、数组末端各设置一个指针p,q。
三数相加,等于0 就把三个数存进数组中。

亿些细节:
for循环的当前值若大于0,则后面的p、q也一定>0。三数之和不可能为0 了,可以跳出循环了。
for循环,i只要不是第一个元素(即下标为0 时),i都要和前一个元素i-1比较,如果相同则可以跳过了,即continue;
(p前进时、q后退时 也都要与上一个元素比较,看是否相同了,相同了就跳过。)
只有三数之和为0之后,再移动p、q时 才需要考虑去重。还没有找到合适的三数之前是不用考虑去重的,因为这根本就不是以后的准结果,何谈去重。

2. 代码

public List<List<Integer>> threeSum(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();

    //1.对数组排序
    Arrays.sort(nums);
    int len = nums.length;

    //i作为第一个元素 其范围是 0<= i <= n-3
    int j, k;
    int sum = 0;
    for(int i = 0; i < len-2; ++i){
        if (nums[i] > 0) {
            break;
        }
        if(i != 0 && nums[i] == nums[i-1]){
            continue;
        }

        j = i + 1;
        k = len - 1;
        while (j < k){
            sum = nums[i] + nums[j] + nums[k];
            if(sum == 0){
                //添加元素的同时,完成了jk指针的移动
                result.add(Arrays.asList(nums[i], nums[j++], nums[k--]));
                //j、k 同i一样 若新值与旧值相同 则继续跳下一个
                while(j < k && nums[j-1] == nums[j]){
                    j++;
                }
                while(k > j && nums[k+1] == nums[k]){
                    k--;
                }
            }else if(sum > 0){//k所指的数字大了,k应向左移
                --k;
            }else {
                ++j;
            }

        }
    }
    return result;

}


public List<List<Integer>> threeSum1(int[] nums) {
    Arrays.sort(nums);
    int p, q;
    int len = nums.length;
    int threeSum;
    List<List<Integer>> result = new ArrayList<>();

    for(int i = 0; i < len; ++i){
        if(nums[i] > 0){
            break;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        //初始化pq
        p = i + 1; q = len - 1;
        while(p < q){
            threeSum = nums[i] + nums[p] + nums[q];
            if(threeSum > 0){//数大了,要小一点
                --q;
            }else if(threeSum < 0){
                ++p;
            }else {
                result.add(Arrays.asList(nums[i], nums[p], nums[q]));
                //继续移动p q
                //当前nums[p],右侧下一个值nums[p+1]
                while(p < q && nums[p] == nums[p + 1]){
                    ++p;
                }
                while(p < q && nums[q] == nums[q - 1]){
                    --q;
                }
                //当与下一个值都不一样时,到了这里,但还没有移动到下一个值的位置
                ++p; --q;
            }
        }

    }
    return result;

}

3. 实现过程中的问题

要清除的知道,在什么时刻对三个数去重。
i在for循环中起始时就要对i去重。
左侧指针、右侧指针:都是在三数之和为0之后。

(四) 18. 四数之和

建议: 要比较一下,本题和 454.四数相加II 的区别,为什么 454.四数相加II 会简单很多,这个想明白了,对本题理解就深刻了。 本题 思路整体和 三数之和一样的,都是双指针,但写的时候 有很多小细节,需要注意,建议先看视频。

题目/文章/视频链接

1. 思路

整体思路与三数之和基本一致。
在三数之和的基础上,i的for循环遍历上,再加一层j的for循环。
并且四数之和的剪枝与三数之和的剪枝有区别。
三数之和判断num[i] > 0 就break了,因为后面的数都比num[i]大,即都>0,所以无法再在后面找到两个数与num[i] 相加 == 0了 .
四数之和,不能num[i] + num[j] > target 就break了。现在比target大,但是num[i] + num[j] 不一定是个正数。若是负数,虽然现在比target大,但右面还有一些负数,四数相加还是有机会 等于 target的。

可以通过这种方式剪枝,nums[i] > target && nums[i] >=0

与四数之和II的区别。四数之和II是在四个数组中分别选数,不用像这里选每个数时都要错开(各种+1),还要排重。

2. 代码

public List<List<Integer>> fourSum1(int[] nums, int target) {
    List<List<Integer>> result = new ArrayList<>();
    Arrays.sort(nums);//排序

    int left, right, sum;
    int len = nums.length;

    for(int i = 0; i < len; ++i){
        //剪枝 去重
        if(nums[i] > target && nums[i] > 0){
            break;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }

        for(int j = i + 1; j < len; ++j){
            //去重
            if(j > i + 1 && nums[j] == nums[j - 1]){
                continue;
            }
            left = j + 1;
            right = len - 1;
            while(left < right){
                sum = nums[i] + nums[j] + nums[left] + nums[right];
                if(sum > target){
                    --right;
                }else if(sum < target){
                    ++left;
                }else {
                    //找到目标组合了,同时迈出了left right向内靠拢的一步
                    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;
                    }

                }
            }

        }
    }
    return result;
}

你可能感兴趣的:(散列表,数据结构,算法,leetcode,java)