leetcode--demo15三数之和

leetcode–demo15三数之和

当时看到这一题的时候我首先想到就是dfs+回溯，我的思想其实很简单就是对自己构造的树形图进行递归遍历，当深度为3的时候进行返回，并将路径保存到列表当中，当然还要考虑一下结果去重以及重复元素的使用。（代码看不懂的去看我之前的博客，dfs套路是一样的）

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[] nums = {-1, 0, 1, 2, -1, -4};
        System.out.println(new Solution1().threeSum(nums));
    }
}

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null) {
            return res;
        }
        List<Integer> path = new ArrayList<>();
        int depth = 0;
        boolean[] used = new boolean[nums.length];
        dfs(res, path, nums, depth, used);
        Set<List<Integer>> set = new HashSet<>();
        for (List<Integer> ele :
                res) {
            Collections.sort(ele);
            set.add(ele);
        }
        res.clear();
        for (List<Integer> ele : set) {
            res.add(ele);
        }
        return res;
    }

    private void dfs(List<List<Integer>> res, List<Integer> path, int[] nums, int depth, boolean[] used) {
        if (depth == 3) {
            if (path.get(0) + path.get(1) + path.get(2) == 0) {
                res.add(new ArrayList<>(path));
            }
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == true) {
                continue;
            } else {
                path.add(nums[i]);
                used[i] = true;
                dfs(res, path, nums, depth + 1, used);
                //回溯
                path.remove(path.size() - 1);
                used[i] = false;
            }
        }
    }
}

然而，提交的时候超时了，只通过了298个测试用例，这就很尴尬，然后我就在想是不是我偷懒没有剪枝，结果LeetCode的一位老哥他是剪枝了的，结果还是没过，然后我就懒得试了，直接换思路。

第二种就是双指针
主要思想：先绑定一个数nums[i],然后左指针初始位置是nums[i+1],右指针初始位置nums[nums.length-1],左右指针向中间逼近，如果sum=0，就把三个数保存下来。当然外层循环的i从0到nums.length-1,这样时间复杂度O(n2),也就还行了。

class Solution1 {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums.length < 3) {
            return res;
        }
        //排序
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            //每次循环的第一个数都大于0的话直接跳出循环
            if (nums[i] > 0) {
                break;
            }
            //去重
            if (i>0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {
                    List<Integer> path = new ArrayList<>();
                    path.add(nums[i]);
                    path.add(nums[left]);
                    path.add(nums[right]);
                    res.add(path);
                    //两指针向内逼近，看有没有其他可能
                    while (left < right && nums[left + 1] == nums[left]) left++;
                    while (left < right && nums[right - 1] == nums[right]) right--;
                    left++;
                    right--;
                } else {
                    if (sum > 0) {
                        right--;
                    }
                    if (sum < 0) {
                        left++;
                    }
                }
            }
        }
        return res;
    }
}

最后留个问题考一下大家，大家知道为什么去重的时候要这样写

			//去重
            if (i>0 && nums[i] == nums[i - 1]) {
                continue;
            }

而不是这样写呢？

			//去重
            if (i<nums.length-1 && nums[i] == nums[i + 1]) {
                continue;
            }