力扣算法 Java 刷题笔记【nSum 问题】hot100（一）团灭 nSum 3

1. 两数之和（简单）

地址: https://leetcode-cn.com/problems/two-sum/
2022/02/11
做题反思：
方法一：暴力穷举 也可这么写 if (nums[i] + nums[j] == target && i != j)

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

方法二：HashMap 减少时间复杂度

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> index = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            index.put(nums[i], i);
        }

        for (int j = 0; j < nums.length; j++) {
            int other = target - nums[j];
            if (index.containsKey(other) && index.get(other) != j) {
                return new int[] {j, index.get(other)};
            }
        }
        return new int[] {-1, -1};
    }
}

方法三：双指针（适用于有序数组）

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int slow = 0, fast = nums.length - 1;
        while (slow < fast) {
            int sum = nums[slow] + nums[fast];
            if (sum < target) {
                slow++;
            }
            if (sum > target) {
                fast--;
            }
            if (sum == target) {
                return new int[]{nums[slow], nums[fast]};
            }
        }
        return null;
    }
}

2. 三数之和（中等）

地址: https://leetcode-cn.com/problems/3sum/
2022/02/13
做题反思：短路运算 while (i < nums.length - 1 && nums[i] == nums[i + 1])

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        return nSumTarget(nums, 3, 0, 0);
    }
    
    List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target) {
        List<List<Integer>> res = new LinkedList<>();
        if (n < 2 || nums.length < n) {
            return res;
        }
        if (n == 2) {
            int l = start, r = nums.length - 1;
            while (l < r) {
                int left = nums[l], right = nums[r];
                int sum = left + right;
                if (sum == target) {
                    res.add(Arrays.asList(left, right));
                    while (l < r && nums[l] == left) {
                        l++;
                    }
                    while (l < r && nums[r] == right) {
                        r--;
                    }
                }
                if (sum < target) {
                    l++;
                }
                if (sum > target) {
                    r--;
                }
            }
        }
        if (n > 2) {
            for (int i = start; i < nums.length; i++) {
                List<List<Integer>> tuples = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for (List<Integer> tuple : tuples) {
                    List<Integer> t = new LinkedList<>(tuple);
                    t.add(nums[i]);
                    res.add(t);
                } 
                while (i < nums.length - 1 && nums[i] == nums[i + 1]) {
                    i++;
                }
            }
        }
        return res;
    }
}

3. 四数之和（中等）

地址: https://leetcode-cn.com/problems/4sum/
2022/02/14
做题反思：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        return nSumTarget(nums, 4, 0, target);
    }

    List<List<Integer>> nSumTarget(int[] nums, int n, int start, int target) {
        List<List<Integer>> res = new LinkedList<>();
        if (n < 2 || nums.length < n) {
            return res;
        }
        if (n == 2) {
            int l = start, r = nums.length - 1;
            while (l < r) {
                int left = nums[l], right = nums[r];
                int sum = left + right;
                if (sum == target) {
                    res.add(Arrays.asList(left, right));
                    while (l < r && nums[l] == left) {
                        l++;
                    }
                    while (l < r && nums[r] == right) {
                        r--;
                    }
                }
                if (sum < target) {
                    l++;
                }
                if (sum > target) {
                    r--;
                }
            }
        }
        if (n > 2) {
            for (int i = start; i < nums.length; i++) {
                List<List<Integer>> tuples = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for (List<Integer> tuple : tuples) {
                    List<Integer> t = new LinkedList<>(tuple);
                    t.add(nums[i]);
                    res.add(t);
                }
                while (i < nums.length - 1 && nums[i] == nums[i + 1]) {
                    i++;
                }
            }
        }
        return res;
    }
}