【LeetCode - 1】两数之和、三数之和、四数之和、N数之和

两数之和_返回两数的下标

题目：
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
思路：
方法一：可以用暴力法进行破解，用双层循环遍历nums。一层遍历第一个加数
代码

int[] twoSum1(int[] nums,int target){
        //穷举这两个数的可能
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == target - nums[i]){
                    return new int[]{i,j};
                }
            }
        }
        //不存在这两个数
        return new int[]{-1,-1};
    }

方法二：可以借助HashMap，将nums加入到HashMap表中，其中nums中的数作为key，索引作为value, 判断Hashmap中存在target-x且这个数的索引值不等于x自身即可。

    //空间换时间，通过一个哈希表记录元素值直到索引的映射，减少时间复杂度
    int[] twoSum2(int[] nums,int target){
        //构造一个哈希表，元素映射到相应的索引
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }
        for (int i = 0;i < nums.length;i++){
            int other = target - nums[i];
            //如果other存在且不是nums[i]本身
            if (map.containsKey(other) && map.get(other) != i){
                return new int[]{map.get(other),i};
            }
        }
        return new int[]{-1,-1};
    }

两数之和，返回两数

题目：输入一个数组nums和一个目标和target，请返回nums中能够凑出target的两个元素，比如输入nums=[1,3,5,6],target = 9，那么算法返回两个元素[3,6]，假设只有一对可以凑出target

思路：
先对nums进行排序，然后利用左右指针，从两端相向而行

 public List<Integer> twoSumTarget(int[] nums,int target) {
        //nums数组必须有序
        Arrays.sort(nums);
        List<Integer> res = new ArrayList<>();
        /* 双指针 */
        int low = 0, high = nums.length - 1;
        /* 不能重复取元素，所以是小于号 */
        while (low < high) {
            int sum = nums[low] + nums[high];
            if (sum == target) {
              return {nums[low],nums[high]};

            } else if (sum < target) {
               low++;

            } else {
                high--;
            }
        }
        return {};
    }

两数之和，多对元素和为target

针对上题，nums中可能有多对元素之和等于target，请返回所有和为target的元素对，其中不能出现重复

比如，输入nums = {1,3,1,2,2,3}，target = 4
那么算法返回的结果就是[[1,3],[2,2]]

思路：
比上面题目的不同时，关键难点在有多个和为target的数对，不能重复，需要保证每个答案只被添加一次，重复的结果都会被跳过，则还是排序加双指针

  public List<List<Integer>> twoSumTarget(int[] nums,int target) {
        //nums数组必须有序
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        /* 双指针 */
        int low = 0, high = nums.length - 1;
        /* 不能重复取元素，所以是小于号 */
        while (low < high) {
            int sum = nums[low] + nums[high];
            /* 记录索引low和high最初对应的值，方便跳过重复元素 */
            int left = nums[low], right = nums[high];

            if (sum == target) {
                /* 把二元组{left, right}添加到res中 */
                List<Integer> tmp = new LinkedList<>();
                tmp.add(left);
                tmp.add(right);
                res.add(tmp);
                /* 两边跳过重复元素 */
                while (low < high && nums[low] == left) low++;
                while (low < high && nums[high] == right) high--;

            } else if (sum < target) {
                /* 左指针跳过重复元素 */
                while (low < high && nums[low] == left) low++;

            } else {
                /* 右指针跳过重复元素 */
                while (low < high && nums[high] == right) high--;
            }
        }
        return res;
    }

三数之和

题目
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
思路：
方法一：穷举法，先确定第一个数字，剩下的两个数字，其实就是和为target - nums[i] 的两个数字，则利用上面方法的两数之和解决

/**
     * 从nums[start]开始，计算有序数组
     * nums中所有和为target的二元组
     * @return
     */
    public List<List<Integer>> threeSum_1(int[] nums) {
        return threeSumTarget(nums,0);
    }
    public List<List<Integer>> twoSumTarget(int[] nums, int start, int target){
        //左指针改为start开始，其他不变
        int lo = start,hi = nums.length - 1;
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        while (lo < hi){
            int sum = nums[lo] + nums[hi];
            int left = nums[lo],right = nums[hi];
            if (sum < target){
                while (lo < hi && nums[lo] == left)
                    lo++;
            }
            else if (sum > target){
                while (lo < hi && nums[hi] == right)
                    hi--;
            }
            else {
                List<Integer> tmp = new LinkedList<>();
                tmp.add(left);
                tmp.add(right);
                res.add(tmp);
                while (lo < hi && nums[lo] == left) lo++;
                while (lo < hi && nums[hi] == right) hi--;
            }
        }
        return res;
    }
    public List<List<Integer>> threeSumTarget(int[] nums,int target){
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        //穷举threeSum 的第一个数
        for (int i = 0;i < nums.length;i++){
            List<List<Integer>> tuples = twoSumTarget(nums,i + 1,target - nums[i]);
            //如果存在满足条件的二元组，再加上nums[i]就是结果三元组
            for (List<Integer> tuple : tuples) {
                tuple.add(nums[i]);
                res.add(tuple);
            }
            //跳过第一个数字重复的情况，否则会出现重复结果
            while (i < nums.length - 1 && nums[i] == nums[i + 1])
                i++;
        }
        return res;
    }

方法二：
跟两数之和不同的是，三数之后要输出的是不同三元组的集合。因此，我们考虑先将nums进行排序，将nums[i]作为第一个加数，从i+1到nums.length-1之间初始化两个指针left，right，为了避免有重复的情况，当nums[i]==nums[i-1],说明有重复的情况，开始下一个循环。如果num[i]+num[left]+num[right]>0,说明加多了，让right–，如果num[i]+num[left]+num[right]<0,说明加少了，让left++，如果等于0，说明符合条件，将这一组解加到集合中，这是也应该避免第二个加数和第三个加数重复的情况。

public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 1; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                if (nums[left] + nums[right] + nums[i] > 0) {
                    right--;
                } else if (nums[left] + nums[right] + nums[i] < 0) {
                    left++;
                } else {
                    list.add(Arrays.asList(nums[left], nums[right], nums[i]));
                    left++;
                    right--;
                    while (left < right && nums[left] == nums[left - 1]) {
                        left++;
                    }
                    while (left < right && nums[right] == nums[right + 1]) {
                        right--;
                    }
                }

            }
        }
        return list;
    }

四数之和_N数之和

方法一：也可以利用上面的方法，先求出三数之和，再求target- nums[i]的方法，但是该方法就冗余太高

方法二：建立一个nSum的解题框架，

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        /* n为3，从nums[0]开始，计算和为0的三元组 */
        return nSumEqualsTarget(nums, 3, 0, 0);
    }

    /* nSum框架，从nums[start]开始，计算和为target的n元组 */
    private List<List<Integer>> nSumEqualsTarget(int[] nums, int n, int start, int target) {
        int sz = nums.length;
        List<List<Integer>> res = new LinkedList<>();
        /* 至少是2Sum，且数组大小不应该小于n */
        if (n < 2 || sz < n) return res;
        /* 2Sum是base case */
        if (n == 2) {
            /* 双指针 */
            int low = start, high = sz - 1;
            /* 不能重复取元素，所以是小于号 */
            while (low < high) {
                int sum = nums[low] + nums[high];
                /* 记录索引low和high最初对应的值，方便跳过重复元素 */
                int left = nums[low], right = nums[high];

                if (sum == target) {
                    /* 把二元组{left, right}添加到res中 */
                    List<Integer> tmp = new LinkedList<>();
                    tmp.add(left);
                    tmp.add(right);
                    res.add(tmp);
                    /* 两边跳过重复元素 */
                    while (low < high && nums[low] == left) low++;
                    while (low < high && nums[high] == right) high--;

                } else if (sum < target) {
                    /* 左指针跳过重复元素 */
                    while (low < high && nums[low] == left) low++;

                } else if (sum > target) {
                    /* 右指针跳过重复元素 */
                    while (low < high && nums[high] == right) high--;
                }
            }
        } else {
            /* n>2时，递归计算(n-1)Sum的结果 */
            for (int i = start; i < sz; i++) {
                /* 对target-nums[i]计算(n-1)Sum */
                List<List<Integer>> sub = nSumEqualsTarget(nums, n - 1, i + 1, target - nums[i]);
                for (List<Integer> arr : sub) {
                    /* 如果存在满足条件的(n-1)元组，则再加上nums[i]就是nSum */
                    arr.add(nums[i]);
                    res.add(arr);
                }
                /* 跳过重复元素，最终i会停在该重复元素的最后一个 */
                while (i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }
}