和为s

和为s的两个数字

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9输出：[2,7] 或者 [7,2]

示例 2：

输入：nums = [10,26,30,31,47,60], target = 40输出：[10,30] 或者 [30,10]

限制：

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^6

双指针

public int[] twoSum(int[] nums, int target) {
    int[] ans = new int[2];
    int low = 0;
    int high = nums.length - 1;
    while (low < high) {
        int sum = nums[low] + nums[high];
        if (sum == target) {
            ans[0] = nums[low];
            ans[1] = nums[high];
            break;
        } else if (sum < target) {
            low++;
        } else {
            high--;
        }
    }
    return ans;
}

和为s的连续正数序列

输入一个正整数 target ，输出所有和为 target 的连续正整数序列(至少含有两个数)。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9输出：[[2,3,4],[4,5]]

示例 2：

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

限制：

• 1 <= target <= 10^5

方法一：暴力
枚举每个起点，判断以它为起点的和是否等于target

• 外层循环上界为target的一半
• 内存循环如果sum>=target结束

public int[][] findContinuousSequence(int target) {
    List<List<Integer>> lists = new ArrayList<>();
    for (int i = 1; i <= target / 2; i++) {
        List<Integer> temp=new ArrayList<>();
        int sum=0;
        for (int j = i;; j++) {
            sum+=j;
            temp.add(j);
            if(sum==target){
                lists.add(temp);
                break;
            } else if(sum>target){
                break;
            }
        }
    }
    int[][] ans=new int[lists.size()][];
    for (int i=0;i<ans.length;i++){
        ans[i]=new int[lists.get(i).size()];
        for (int j = 0; j < ans[i].length; j++) {
            ans[i][j]=lists.get(i).get(j);
        }
    }
    return ans;
}

时间复杂度O(n^3/2)
外层循环n/2次，内层求和n^1/2次(求和公式含平方)方法二：数学优化
应用求根公式
如果知道起点 x 和终点 y ，那么 x 累加到 y 的和由求和公式可以知道是(x+y)(x+y-1)/2

问题就转化为了是否存在一个正整数 y(y>x)，满足等式(x+y)(x+y-1)/2=target

转化一下变成 y²+y-x²+x-2*target=0

这是一个关于 y 的一元二次方程，其中 a=1,b=1,c=-x²+x-2*target
用求根公式即可 O(1) 解得 y=(-b+/-(b²-4ac)^1/2)/2

public int[][] findContinuousSequence(int target) {
    List<List<Integer>> lists = new ArrayList<>();
    for (long i = 1; i <= (target - 1) / 2; i++) {//long 因为可能数字很大计算结果溢出
        double sqrt = Math.sqrt(1 - 4 * (-i * i + i - 2 * target));
        if (sqrt != (int) sqrt) {
            continue;
        }
        int y = -1 + (int) sqrt;
        if (y % 2 == 0 && y / 2 >= i && y / 2 < target) {
            List<Integer> temp = new ArrayList<>();
            for (int j = (int) i; j <= y / 2; j++) {
                temp.add(j);
            }
            lists.add(temp);
        }
    }
    int[][] ans = new int[lists.size()][];
    for (int i = 0; i < ans.length; i++) {
        ans[i] = new int[lists.get(i).size()];
        for (int j = 0; j < ans[i].length; j++) {
            ans[i][j] = lists.get(i).get(j);
        }
    }
    return ans;
}

时间复杂度O(n)

方法三：双指针
low=1 high=2

• sum<target，说明指针 high还可以向右拓展使得 sum增大，high++
• sum>target，说明以 low 为起点不存在一个 high 使得 sum=target，此时要枚举下一个起点，low++
• sum==target，说明找到了以 low 为起点得合法解[low,high] ，high++或者low++，查找下一种情况
• 终止条件low>=high的时候，这种情况的发生指针high 移动到了上界target的一半，导致和始终大于 target

此方法其实是对方法一的优化，因为方法一是没有考虑区间与区间的信息可以复用，只是单纯的枚举起点，然后从起点开始累加，而该方法就是考虑到了如果已知 [l,r][l,r] 的区间和等于 target ，那么枚举下一个起点的时候，区间 [low+1,high] 的和必然小于 target ，我们就不需要再从low+1 再开始重复枚举，而是从 high+1开始枚举，充分的利用了已知的信息来优化时间复杂度

public int[][] findContinuousSequence(int target) {
    List<List<Integer>> lists = new ArrayList<>();
    int low = 1;
    int high = 2;
    while (low < high) {
        int sum = (low + high) * (high - low + 1) / 2;
        if (sum == target) {
            List<Integer> temp = new ArrayList<>();
            for (int j = low; j <= high; j++) {
                temp.add(j);
            }
            lists.add(temp);
            high++;
        } else if (sum < target) {
            high++;
        } else {
            low++;
        }
    }
    int[][] ans = new int[lists.size()][];
    for (int i = 0; i < ans.length; i++) {
        ans[i] = new int[lists.get(i).size()];
        for (int j = 0; j < ans[i].length; j++) {
            ans[i][j] = lists.get(i).get(j);
        }
    }
    return ans;
}

时间复杂度O(n)