每日一题：LeetCode 15.三数之和

先来看下两数之和是怎么解决的？

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

 

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]
 

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力解法，双层循环，时间复杂度o(n),空间复杂度o(1)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0;i < nums.length - 1;i++){
            for(int j = i+1;j < nums.length;j++){
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return nums;
    }
}

用空间换时间，每遍历一个元素，看看 hashMap 中是否存在满足要求的目标数字,时间复杂度o(1),空间复杂度o(n)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> res = new HashMap();
        for(int i = 0;i < nums.length;i++){
            if(res.containsKey(target - nums[i])){
                return new int[]{i,res.get(target - nums[i])};
            }
            res.put(nums[i],i);
        }
        return nums;
    }
}

再来看三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

 

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：

输入：nums = []
输出：[]
示例 3：

输入：nums = [0]
输出：[]
 

提示：

0 <= nums.length <= 3000
-105 <= nums[i] <= 105

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力解法，但是存在重复元素的问题，时间复杂度o(n^3), 去掉为了解答而创建的集合，空间复杂度o(1)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        for(int i = 0;i < nums.length - 2;i++){
            for(int j = i+1;j < nums.length - 1;j++){
                for(int k = j+1;k < nums.length;k++){
                    if(nums[i] + nums[j] + nums[k] == 0){
                        List<Integer> temp = new ArrayList();
                        temp.add(nums[i]);
                        temp.add(nums[j]);
                        temp.add(nums[k]);
                        res.add(temp);
                    }
                }
            }
        }
        return res;
    }
}

「不重复」的本质是什么？我们保持三重循环的大框架不变，只需要保证：

第二重循环枚举到的元素不小于当前第一重循环枚举到的元素；

第三重循环枚举到的元素不小于当前第二重循环枚举到的元素。

也就是说，我们枚举的三元组 num[i],num[j],num[k] 满足 num[i]≤num[j]≤num[k]，保证了只有 num[i],num[j],num[k] 这个顺序会被枚举到，而 num[j],num[i],num[k] 、num[k],num[j],num[i] 等等这些不会，这样就减少了重复。要实现这一点，我们可以将数组中的元素从小到大进行排序，随后使用普通的三重循环就可以满足上面的要求。

同时，对于每一重循环而言，相邻两次枚举的元素不能相同，否则也会造成重复。

public static List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for(int i = 0;i < nums.length - 2;i++){
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            for(int j = i+1;j < nums.length - 1;j++){
                if(j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                for(int k = j+1;k < nums.length;k++){
                    if(k > j+1 && nums[k] == nums[k-1]){
                        continue;
                    }
                    if(nums[i] + nums[j] + nums[k] == 0){
                        List<Integer> temp = new ArrayList();
                        temp.add(nums[i]);
                        temp.add(nums[j]);
                        temp.add(nums[k]);
                        res.add(temp);
                    }
                }
            }
        }
        return res;
    }

即使去重了，暴力法搜索还是为 O(N^3)时间复杂度，可通过双指针动态消去无效解来优化效率。

为什么双指针可以去除重复的判断？具体思考路径如下：

由于集合是有序的，所以我们可以从小到大枚举 num[j]，同时从大到小枚举num[k]，即第二重循环和第三重循环实际上是并列的关系。

有了这样的发现，我们就可以保持第二重循环不变，而将第三重循环变成一个从数组最右端开始向左移动的指针.这样子就减少了一层不必要的循环体。

这个方法就是我们常说的「双指针」，当我们需要枚举数组中的两个元素时，如果我们发现随着第一个元素的递增，第二个元素是递减的，那么就可以使用双指针的方法，减少多余的循环体，将枚举的时间复杂度降下来

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //排序
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for(int i = 0;i < nums.length - 2;i++){
            //去掉不可能的情况
            if(nums[i] > 0)break;
            //除了第一次循环，以后每一次循环的时候，保证不要重复
            if(i> 0 && nums[i] == nums[i - 1])continue;

            //定义双指针，左右夹逼
            int j = i+1;int k = nums.length - 1;
            while(j < k){
                //根据sum的大小去判断是移动大的索引还是小的索引
                int sum = nums[i] + nums[j] + nums[k];
                if(sum > 0){
                    //太大了，缩小大的索引，循环判断，去掉所有相同的元素
                    while(j < k && nums[k] == nums[--k]);
                }else if(sum < 0){
                    //太小了，扩大小的索引，循环判断，去掉所有相同的元素
                    while(j < k && nums[j] == nums[++j]);
                }else{
                    res.add(Arrays.asList(nums[i], nums[j], nums[k]));
                    //同时移动最大和最小的索引，同时做去重判断
                    while(j < k && nums[k] == nums[--k]);
                    while(j < k && nums[j] == nums[++j]);
                    //保证下一次循环不会重复！
                }
            }
        }
        return res;
    }
}

具体逻辑做了什么？

{-1, 0, 1, 2, -1, -4};
首先排序，确定指针所在的位置
{-4, -1, -1, 0, 1, 2};
  i  j->          <-k
然后根据三数之和的大小值，去移动对应的指针。如果sum >0，表示太大了，移动k。如果sum <0，表示太小了，移动j
{-4, -1, -1, 0, 1, 2};
      i  j->      <-k
{-4, -1, -1, 0, 1, 2};
          i j->   <-k