【双指针&遍历】N数之和问题

二数之和LC1

题目链接

给定一个整数数组 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]
1
2
3
4
5
6
7
8
9
10
11
12
13

代码：

// 仅需一次for循环
class Solution {
    public int[] twoSum(int[] nums, int target) {
         Map<Integer,Integer> map = new HashMap<>();
         for(int i = 0; i < nums.length;i++){
            int cur = target - nums[i]; 
            if(map.containsKey(cur)){
                int x = map.get(cur);
                return new int[]{x,i};
            }
            map.put(nums[i],i);
         }
         return new int[]{-1,-1}; 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三数之和LC15

题目链接

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

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

示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：
输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：
输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

代码：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        
        int len = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> finalres = new ArrayList<>();
        for(int i = 0; i < len-2;i++){
            int cur = nums[i];
            int l = i+1;
            int r = len-1;
            while(l < r){
                int left = nums[l];
                int right = nums[r];
                int sum = cur+left+right;
                if(sum > 0){
                    while(l<r&&nums[r]==right)r--;// 移动指针，并排除相同元素
                }
                else if(sum<0){
                    while(l<r&&nums[l]==left)l++;// 移动指针，并排除相同元素
                }else{
                    List<Integer> res = new ArrayList<>();
                    res.add(cur);
                    res.add(left);
                    res.add(right);
                    finalres.add(res);
                    while(l<r&&nums[r]==right)r--;// 移动指针，并排除相同元素
                    while(l<r&&nums[l]==left)l++;// 移动指针，并排除相同元素
                }
            }
            while(i<len-2&&nums[i+1]==cur)i++;
        }
        return finalres;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

四数之和LC18

题目链接

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

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

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

代码：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
            Arrays.sort(nums);// 先排序
            return nTargetSum(nums,0,4,target);// 从数组0下标开始找，找4个数
    }
    
    public List<List<Integer>> nTargetSum(int[] nums,int i,int needNum,long target){
            // if(needNum < 2){
            //     List> res = new ArrayList<>();
            //     return res;
            // }
            if(needNum==2){// 转换为二数之和
                List<List<Integer>> res = new ArrayList<>();
                int l = i;
                int r = nums.length-1;
                while(l<r){
                    int left = nums[l];
                    int right = nums[r];
                    if(left+right==target){
                        List<Integer> re = new ArrayList<>(Arrays.asList(left,right));
                        res.add(re);
                        while(l<r && nums[r]==right)r--;
                        while(l<r && nums[l]==left)l++;
                    }else if(left+right>target){
                        while(l<r && nums[r]==right)r--;
                    }else if(left+right<target){
                        while(l<r && nums[l]==left)l++;
                    }
                }
                return res;
            }else{// 递归部分
                List<List<Integer>> finalr = new ArrayList<>();
                for(int j = i ; j < nums.length;j++){
                    List<List<Integer>> sub = nTargetSum(nums,j+1,needNum-1,target-nums[j]);
                    for(List<Integer> list:sub){
                        list.add(nums[j]);
                        finalr.add(list);
                    }
                    while(j+1 < nums.length && nums[j+1] == nums[j])j++;// 排序相同元素
                }
                return finalr;
            }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

最接近的三数之和LC16

题目链接

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

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

代码：

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);// 注意先排序
        int finalresult = nums[0]+nums[1]+nums[2];
        int minCha = Integer.MAX_VALUE;
        int len = nums.length;
        for(int i = 0; i < nums.length-2;i++){// 第一个数指针
            int l = i+1;// 第2个数指针
            int r = nums.length-1;// 第3个数指针
            while(l<r){
                int mysum = nums[i]+nums[l]+nums[r];// 三数之和
                if(Math.abs(mysum-target) < minCha){// 更新答案
                    finalresult = mysum;
                    minCha = Math.abs(mysum-target);
                }
                if(mysum>target){
                    r--;
                }else if(mysum<target){
                    l++;
                }else{
                    return target;
                }
            }
        }
        return finalresult;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27